=ID Properties=
This commit adds supports for per-ID properties to blender. See http://mediawiki.blender.org/index.php/BlenderDev/ID_Property for more information on how it all works. ID properties are accesable by python; but note that bindings have only been added to Object and Material thus far. However adding more bindings is easy and I plan on adding several more hopefully within an hour of this inital commit. A generic UI panel is also planned, that will go wherever its needed; for example in the material buttons, editing buttons, etc. I'll likely submit the initial code for that as a patch, though, so matt and ton and others can go over it and make sure it's all good. :) VERY important, if you intend to use ID properties please go to http://mediawiki.blender.org/index.php/BlenderDev/PropertyStandards and start writing the appropriate standards for it.
This commit is contained in:
Joseph Eagar
1007
source/blender/python/api2_2x/IDProp.c
Normal file
1007
source/blender/python/api2_2x/IDProp.c
Normal file
@@ -0,0 +1,1007 @@
|
||||
#include "DNA_ID.h"
|
||||
|
||||
#include "BKE_idprop.h"
|
||||
|
||||
#include "IDProp.h"
|
||||
#include "gen_utils.h"
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
#define BSTR_EQ(a, b) (*(a) == *(b) && !strcmp(a, b))
|
||||
|
||||
/*** Function to wrap ID properties ***/
|
||||
PyObject *BPy_Wrap_IDProperty(ID *id, IDProperty *prop);
|
||||
|
||||
extern PyTypeObject IDArray_Type;
|
||||
|
||||
/*********************** ID Property Main Wrapper Stuff ***************/
|
||||
void IDProperty_dealloc(BPy_IDProperty *self)
|
||||
{
|
||||
if (self->data_wrap) {
|
||||
Py_XDECREF(self->data_wrap);
|
||||
}
|
||||
|
||||
/*if (self->destroy) {
|
||||
IDP_FreeProperty(self->prop);
|
||||
MEM_freeN(self->prop);
|
||||
}*/
|
||||
|
||||
PyObject_DEL(self);
|
||||
}
|
||||
|
||||
PyObject *IDProperty_repr(BPy_IDProperty *self)
|
||||
{
|
||||
return Py_BuildValue("s", "(ID Property)");
|
||||
}
|
||||
|
||||
extern PyTypeObject IDGroup_Type;
|
||||
|
||||
PyObject *BPy_IDProperty_getattr(BPy_IDProperty *self, char *name)
|
||||
{
|
||||
if (BSTR_EQ(name, "data")) {
|
||||
switch (self->prop->type) {
|
||||
case IDP_STRING:
|
||||
return Py_BuildValue("s", self->prop->data.pointer);
|
||||
case IDP_INT:
|
||||
return Py_BuildValue("i", self->prop->data.val);
|
||||
case IDP_FLOAT:
|
||||
return Py_BuildValue("f", *(float*)(&self->prop->data.val));
|
||||
case IDP_GROUP:
|
||||
/*blegh*/
|
||||
if (self->data_wrap) {
|
||||
Py_XINCREF(self->data_wrap);
|
||||
return self->data_wrap;
|
||||
} else {
|
||||
BPy_IDProperty *group = PyObject_New(BPy_IDProperty, &IDGroup_Type);
|
||||
group->id = self->id;
|
||||
group->data_wrap = NULL;
|
||||
group->prop = self->prop;
|
||||
Py_XINCREF(group);
|
||||
self->data_wrap = (PyObject*) group;
|
||||
return (PyObject*) group;
|
||||
}
|
||||
case IDP_ARRAY:
|
||||
if (self->data_wrap) {
|
||||
Py_XINCREF(self->data_wrap);
|
||||
return self->data_wrap;
|
||||
} else {
|
||||
BPy_IDProperty *array = PyObject_New(BPy_IDProperty, &IDArray_Type);
|
||||
array->id = self->id;
|
||||
array->data_wrap = NULL;
|
||||
array->prop = self->prop;
|
||||
Py_XINCREF(array);
|
||||
self->data_wrap = (PyObject*) array;
|
||||
return (PyObject*) array;
|
||||
}
|
||||
case IDP_MATRIX:
|
||||
case IDP_VECTOR:
|
||||
break;
|
||||
}
|
||||
} else if (BSTR_EQ(name, "name")) {
|
||||
return Py_BuildValue("s", self->prop->name);
|
||||
} else if (BSTR_EQ(name, "type")) {
|
||||
return Py_BuildValue("i", self->prop->type);
|
||||
//} else if (BSTR_EQ(name, "object")) {
|
||||
/*hrm the idea is here is to return the wrapped ID object. how the hell
|
||||
do I do that? eek! */
|
||||
} else if (BSTR_EQ(name, "__member__"))
|
||||
return Py_BuildValue("[s, s, s]", "data", "name", "type");
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int BPy_IDProperty_setattr(BPy_IDProperty *self, char *name, PyObject *val)
|
||||
{
|
||||
if (BSTR_EQ(name, "type"))
|
||||
return EXPP_ReturnIntError(PyExc_TypeError, "attempt to set read-only attribute!");
|
||||
else if (BSTR_EQ(name, "name")) {
|
||||
char *st;
|
||||
if (!PyString_Check(val))
|
||||
return EXPP_ReturnIntError(PyExc_TypeError, "expected a string!");
|
||||
|
||||
st = PyString_AsString(val);
|
||||
if (strlen(st) >= MAX_IDPROP_NAME)
|
||||
return EXPP_ReturnIntError(PyExc_TypeError, "string length cannot exceed 31 characters!");
|
||||
|
||||
strcpy(self->prop->name, st);
|
||||
return 0;
|
||||
} else if (BSTR_EQ(name, "data")) {
|
||||
switch (self->prop->type) {
|
||||
case IDP_STRING:
|
||||
{
|
||||
char *st;
|
||||
if (!PyString_Check(val))
|
||||
return EXPP_ReturnIntError(PyExc_TypeError, "expected a string!");
|
||||
|
||||
st = PyString_AsString(val);
|
||||
IDP_ResizeArray(self->prop, strlen(st)+1);
|
||||
strcpy(self->prop->data.pointer, st);
|
||||
return 0;
|
||||
}
|
||||
|
||||
case IDP_INT:
|
||||
{
|
||||
int ival;
|
||||
if (!PyNumber_Check(val))
|
||||
return EXPP_ReturnIntError(PyExc_TypeError, "expected an int!");
|
||||
val = PyNumber_Int(val);
|
||||
if (!val)
|
||||
return EXPP_ReturnIntError(PyExc_TypeError, "expected an int!");
|
||||
ival = (int) PyInt_AsLong(val);
|
||||
self->prop->data.val = ival;
|
||||
Py_XDECREF(val);
|
||||
break;
|
||||
}
|
||||
case IDP_FLOAT:
|
||||
{
|
||||
float fval;
|
||||
if (!PyNumber_Check(val))
|
||||
return EXPP_ReturnIntError(PyExc_TypeError, "expected a float!");
|
||||
val = PyNumber_Float(val);
|
||||
if (!val)
|
||||
return EXPP_ReturnIntError(PyExc_TypeError, "expected a float!");
|
||||
fval = (float) PyFloat_AsDouble(val);
|
||||
*(float*)&self->prop->data.val = fval;
|
||||
Py_XDECREF(val);
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
return EXPP_ReturnIntError(PyExc_AttributeError, "attempt to set read-only attribute!");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
return EXPP_ReturnIntError(PyExc_TypeError, "invalid attribute!");
|
||||
}
|
||||
|
||||
int BPy_IDProperty_Map_Len(BPy_IDProperty *self)
|
||||
{
|
||||
if (self->prop->type != IDP_GROUP)
|
||||
return EXPP_ReturnIntError( PyExc_TypeError,
|
||||
"len() of unsized object");
|
||||
|
||||
return self->prop->len;
|
||||
}
|
||||
|
||||
PyObject *BPy_IDProperty_Map_GetItem(BPy_IDProperty *self, PyObject *item)
|
||||
{
|
||||
IDProperty *loop;
|
||||
char *st;
|
||||
|
||||
if (self->prop->type != IDP_GROUP)
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"unsubscriptable object");
|
||||
|
||||
if (!PyString_Check(item))
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"only strings are allowed as keys of ID properties");
|
||||
|
||||
st = PyString_AsString(item);
|
||||
for (loop=self->prop->data.group.first; loop; loop=loop->next) {
|
||||
if (BSTR_EQ(loop->name, st)) return BPy_Wrap_IDProperty(self->id, loop);
|
||||
}
|
||||
return EXPP_ReturnPyObjError( PyExc_KeyError,
|
||||
"key not in subgroup dict");
|
||||
}
|
||||
|
||||
/*returns NULL on success, error string on failure*/
|
||||
char *BPy_IDProperty_Map_ValidateAndCreate(char *name, IDProperty *group, PyObject *ob)
|
||||
{
|
||||
IDProperty *prop = NULL;
|
||||
IDPropertyTemplate val;
|
||||
|
||||
if (PyFloat_Check(ob)) {
|
||||
val.f = (float) PyFloat_AsDouble(ob);
|
||||
prop = IDP_New(IDP_FLOAT, val, name);
|
||||
} else if (PyInt_Check(ob)) {
|
||||
val.i = (int) PyInt_AsLong(ob);
|
||||
prop = IDP_New(IDP_INT, val, name);
|
||||
} else if (PyString_Check(ob)) {
|
||||
val.str = PyString_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_FLOAT;
|
||||
else if (!PyInt_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);
|
||||
Py_XDECREF(item);
|
||||
if (val.array.type == IDP_INT) {
|
||||
item = PyNumber_Int(item);
|
||||
((int*)prop->data.pointer)[i] = (int)PyInt_AsLong(item);
|
||||
} else {
|
||||
item = PyNumber_Float(item);
|
||||
((float*)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 (!PyString_Check(key)) {
|
||||
IDP_FreeProperty(prop);
|
||||
MEM_freeN(prop);
|
||||
Py_XDECREF(key);
|
||||
Py_XDECREF(pval);
|
||||
return "invalid element in subgroup dict template!";
|
||||
}
|
||||
if (BPy_IDProperty_Map_ValidateAndCreate(PyString_AsString(key), prop, pval)) {
|
||||
IDP_FreeProperty(prop);
|
||||
MEM_freeN(prop);
|
||||
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);
|
||||
}
|
||||
|
||||
IDP_AddToGroup(group, prop);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int BPy_IDProperty_Map_SetItem(BPy_IDProperty *self, PyObject *key, PyObject *val)
|
||||
{
|
||||
char *err;
|
||||
|
||||
if (self->prop->type != IDP_GROUP)
|
||||
return EXPP_ReturnIntError( PyExc_TypeError,
|
||||
"unsubscriptable object");
|
||||
|
||||
if (!PyString_Check(key))
|
||||
return EXPP_ReturnIntError( PyExc_TypeError,
|
||||
"only strings are allowed as subgroup keys" );
|
||||
|
||||
err = BPy_IDProperty_Map_ValidateAndCreate(PyString_AsString(key), self->prop, val);
|
||||
if (err) return EXPP_ReturnIntError( PyExc_RuntimeError, err );
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
PyMappingMethods BPy_IDProperty_Mapping = {
|
||||
(inquiry)BPy_IDProperty_Map_Len, /*inquiry mp_length */
|
||||
(binaryfunc)BPy_IDProperty_Map_GetItem, /*binaryfunc mp_subscript */
|
||||
(objobjargproc)BPy_IDProperty_Map_SetItem, /*objobjargproc mp_ass_subscript */
|
||||
};
|
||||
|
||||
PyTypeObject IDProperty_Type = {
|
||||
PyObject_HEAD_INIT( NULL ) /* required py macro */
|
||||
0, /* ob_size */
|
||||
/* For printing, in format "<module>.<name>" */
|
||||
"Blender IDProperty", /* char *tp_name; */
|
||||
sizeof( BPy_IDProperty ), /* int tp_basicsize; */
|
||||
0, /* tp_itemsize; For allocation */
|
||||
|
||||
/* Methods to implement standard operations */
|
||||
|
||||
( destructor ) IDProperty_dealloc,/* destructor tp_dealloc; */
|
||||
NULL, /* printfunc tp_print; */
|
||||
(getattrfunc) BPy_IDProperty_getattr, /* getattrfunc tp_getattr; */
|
||||
(setattrfunc) BPy_IDProperty_setattr, /* setattrfunc tp_setattr; */
|
||||
NULL, /* cmpfunc tp_compare; */
|
||||
( reprfunc ) IDProperty_repr, /* reprfunc tp_repr; */
|
||||
|
||||
/* Method suites for standard classes */
|
||||
|
||||
NULL, /* PyNumberMethods *tp_as_number; */
|
||||
NULL, /* PySequenceMethods *tp_as_sequence; */
|
||||
&BPy_IDProperty_Mapping, /* PyMappingMethods *tp_as_mapping; */
|
||||
|
||||
/* More standard operations (here for binary compatibility) */
|
||||
|
||||
NULL, /* hashfunc tp_hash; */
|
||||
NULL, /* ternaryfunc tp_call; */
|
||||
NULL, /* reprfunc tp_str; */
|
||||
NULL, /* getattrofunc tp_getattro; */
|
||||
NULL, /* 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; */
|
||||
};
|
||||
|
||||
/*********** Main wrapping function *******/
|
||||
PyObject *BPy_Wrap_IDProperty(ID *id, IDProperty *prop)
|
||||
{
|
||||
BPy_IDProperty *wrap = PyObject_New(BPy_IDProperty, &IDProperty_Type);
|
||||
wrap->prop = prop;
|
||||
wrap->id = id;
|
||||
wrap->data_wrap = NULL;
|
||||
//wrap->destroy = 0;
|
||||
return (PyObject*) wrap;
|
||||
}
|
||||
|
||||
|
||||
/********Array Wrapper********/
|
||||
|
||||
void IDArray_dealloc(void *self)
|
||||
{
|
||||
PyObject_DEL(self);
|
||||
}
|
||||
|
||||
PyObject *IDArray_repr(BPy_IDArray *self)
|
||||
{
|
||||
return Py_BuildValue("s", "(ID Array)");
|
||||
}
|
||||
|
||||
PyObject *BPy_IDArray_getattr(BPy_IDArray *self, char *name)
|
||||
{
|
||||
if (BSTR_EQ(name, "len")) return Py_BuildValue("i", self->prop->len);
|
||||
else if (BSTR_EQ(name, "type")) return Py_BuildValue("i", self->prop->subtype);
|
||||
else return NULL;
|
||||
}
|
||||
|
||||
int BPy_IDArray_setattr(BPy_IDArray *self, PyObject *val, char *name)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
int BPy_IDArray_Len(BPy_IDArray *self)
|
||||
{
|
||||
return self->prop->len;
|
||||
}
|
||||
|
||||
PyObject *BPy_IDArray_GetItem(BPy_IDArray *self, int index)
|
||||
{
|
||||
if (index < 0 || index >= self->prop->len)
|
||||
return EXPP_ReturnPyObjError( PyExc_IndexError,
|
||||
"index out of range!");
|
||||
|
||||
switch (self->prop->subtype) {
|
||||
case IDP_FLOAT:
|
||||
return Py_BuildValue("f", ((float*)self->prop->data.pointer)[index]);
|
||||
break;
|
||||
case IDP_INT:
|
||||
return Py_BuildValue("i", ((int*)self->prop->data.pointer)[index]);
|
||||
break;
|
||||
/*case IDP_LISTARRAY:
|
||||
return BPy_Wrap_IDProperty(self->id, ((IDProperty**)self->prop->data.array)[index]);
|
||||
break;*/
|
||||
}
|
||||
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
|
||||
"invalid/corrupt array type!");
|
||||
}
|
||||
|
||||
int BPy_IDArray_SetItem(BPy_IDArray *self, int index, PyObject *val)
|
||||
{
|
||||
int i;
|
||||
float f;
|
||||
|
||||
if (index < 0 || index >= self->prop->len)
|
||||
return EXPP_ReturnIntError( PyExc_RuntimeError,
|
||||
"index out of range!");
|
||||
|
||||
switch (self->prop->subtype) {
|
||||
case IDP_FLOAT:
|
||||
if (!PyNumber_Check(val)) return EXPP_ReturnIntError( PyExc_TypeError,
|
||||
"expected a float");
|
||||
val = PyNumber_Float(val);
|
||||
if (!val) return EXPP_ReturnIntError( PyExc_TypeError,
|
||||
"expected a float");
|
||||
|
||||
f = (float) PyFloat_AsDouble(val);
|
||||
((float*)self->prop->data.pointer)[index] = f;
|
||||
Py_XDECREF(val);
|
||||
break;
|
||||
case IDP_INT:
|
||||
if (!PyNumber_Check(val)) return EXPP_ReturnIntError( PyExc_TypeError,
|
||||
"expected an int");
|
||||
val = PyNumber_Int(val);
|
||||
if (!val) return EXPP_ReturnIntError( PyExc_TypeError,
|
||||
"expected an int");
|
||||
|
||||
i = (int) PyInt_AsLong(val);
|
||||
((int*)self->prop->data.pointer)[index] = i;
|
||||
Py_XDECREF(val);
|
||||
break;
|
||||
/*case IDP_LISTARRAY:
|
||||
if (!PyObject_TypeCheck(val, &IDProperty_Type))
|
||||
return EXPP_ReturnIntError( PyExc_TypeError,
|
||||
"expected an IDProperty");
|
||||
|
||||
if (((IDProperty**)self->prop->data.array)[index]) {
|
||||
IDP_FreeProperty(((IDProperty**)self->prop->data.array)[index]);
|
||||
MEM_freeN(((IDProperty**)self->prop->data.array)[index]);
|
||||
}
|
||||
((IDProperty**)self->prop->data.array)[index] = ((BPy_IDProperty*);
|
||||
break;*/
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static PySequenceMethods BPy_IDArray_Seq = {
|
||||
(inquiry) BPy_IDArray_Len, /* inquiry sq_length */
|
||||
0, /* binaryfunc sq_concat */
|
||||
0, /* intargfunc sq_repeat */
|
||||
(intargfunc)BPy_IDArray_GetItem, /* intargfunc sq_item */
|
||||
0, /* intintargfunc sq_slice */
|
||||
(intobjargproc)BPy_IDArray_SetItem, /* intobjargproc sq_ass_item */
|
||||
0, /* intintobjargproc sq_ass_slice */
|
||||
0, /* objobjproc sq_contains */
|
||||
/* Added in release 2.0 */
|
||||
0, /* binaryfunc sq_inplace_concat */
|
||||
0, /* intargfunc sq_inplace_repeat */
|
||||
};
|
||||
|
||||
PyTypeObject IDArray_Type = {
|
||||
PyObject_HEAD_INIT( NULL ) /* required py macro */
|
||||
0, /* ob_size */
|
||||
/* For printing, in format "<module>.<name>" */
|
||||
"Blender IDArray", /* char *tp_name; */
|
||||
sizeof( BPy_IDArray ), /* int tp_basicsize; */
|
||||
0, /* tp_itemsize; For allocation */
|
||||
|
||||
/* Methods to implement standard operations */
|
||||
|
||||
( destructor ) IDArray_dealloc,/* destructor tp_dealloc; */
|
||||
NULL, /* printfunc tp_print; */
|
||||
( getattrfunc ) BPy_IDArray_getattr, /* getattrfunc tp_getattr; */
|
||||
( setattrfunc ) BPy_IDArray_setattr, /* setattrfunc tp_setattr; */
|
||||
NULL, /* cmpfunc tp_compare; */
|
||||
( reprfunc ) IDArray_repr, /* reprfunc tp_repr; */
|
||||
|
||||
/* Method suites for standard classes */
|
||||
|
||||
NULL, /* PyNumberMethods *tp_as_number; */
|
||||
&BPy_IDArray_Seq, /* 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; */
|
||||
NULL, /* getattrofunc tp_getattro; */
|
||||
NULL, /* 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
|
||||
};
|
||||
|
||||
/*********** ID Property Group iterator ********/
|
||||
void IDGroup_Iter_dealloc(void *self)
|
||||
{
|
||||
PyObject_DEL(self);
|
||||
}
|
||||
|
||||
PyObject *IDGroup_Iter_repr(BPy_IDGroup_Iter *self)
|
||||
{
|
||||
return Py_BuildValue("s", "(ID Property Group)");
|
||||
}
|
||||
|
||||
PyObject *BPy_IDGroup_Iter_getattr(BPy_IDGroup_Iter *self, char *name)
|
||||
{
|
||||
return Py_BuildValue("(s)", "None!! Not implemented!!");
|
||||
}
|
||||
|
||||
PyObject *BPy_IDGroup_Iter_setattr(BPy_IDGroup_Iter *self, PyObject *val, char *name)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
PyObject *BPy_Group_Iter_Next(BPy_IDGroup_Iter *self)
|
||||
{
|
||||
IDProperty *cur=NULL;
|
||||
|
||||
if (self->cur) {
|
||||
cur = self->cur;
|
||||
self->cur = self->cur->next;
|
||||
return BPy_Wrap_IDProperty(self->group->id, cur);
|
||||
} else {
|
||||
return EXPP_ReturnPyObjError( PyExc_StopIteration,
|
||||
"iterator at end" );
|
||||
}
|
||||
}
|
||||
|
||||
PyTypeObject IDGroup_Iter_Type = {
|
||||
PyObject_HEAD_INIT( NULL ) /* required py macro */
|
||||
0, /* ob_size */
|
||||
/* For printing, in format "<module>.<name>" */
|
||||
"Blender IDGroup_Iter", /* char *tp_name; */
|
||||
sizeof( BPy_IDGroup_Iter ), /* int tp_basicsize; */
|
||||
0, /* tp_itemsize; For allocation */
|
||||
|
||||
/* Methods to implement standard operations */
|
||||
|
||||
( destructor ) IDGroup_Iter_dealloc,/* destructor tp_dealloc; */
|
||||
NULL, /* printfunc tp_print; */
|
||||
(getattrfunc) BPy_IDGroup_Iter_getattr, /* getattrfunc tp_getattr; */
|
||||
(setattrfunc) BPy_IDGroup_Iter_setattr, /* setattrfunc tp_setattr; */
|
||||
NULL, /* cmpfunc tp_compare; */
|
||||
( reprfunc ) IDGroup_Iter_repr, /* reprfunc 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; */
|
||||
NULL, /* getattrofunc tp_getattro; */
|
||||
NULL, /* 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; */
|
||||
(iternextfunc) BPy_Group_Iter_Next, /* iternextfunc tp_iternext; */
|
||||
};
|
||||
|
||||
/*********** ID Property Group wrapper **********/
|
||||
PyObject *BPy_IDGroup_NewProperty(BPy_IDProperty *self, PyObject *args);
|
||||
PyObject *BPy_IDGroup_DeleteProperty(BPy_IDProperty *self, PyObject *args);
|
||||
|
||||
static PyMethodDef BPy_IDGroup_methods[] = {
|
||||
/* name, method, flags, doc */
|
||||
{"newProperty", ( PyCFunction ) BPy_IDGroup_NewProperty, METH_VARARGS,
|
||||
"Create a new ID property and attach to group."},
|
||||
{"deleteProperty", ( PyCFunction ) BPy_IDGroup_DeleteProperty, METH_VARARGS,
|
||||
"Delete an ID property. Takes either a string of the id property to be deleted,\n \
|
||||
or a reference to the ID property itself as an argument"},
|
||||
{NULL},
|
||||
};
|
||||
|
||||
void IDGroup_dealloc(void *self)
|
||||
{
|
||||
PyObject_DEL(self);
|
||||
}
|
||||
|
||||
PyObject *IDGroup_repr(BPy_IDProperty *self)
|
||||
{
|
||||
return Py_BuildValue("s", "(ID Property Group)");
|
||||
}
|
||||
|
||||
PyObject *BPy_IDGroup_getattr(BPy_IDProperty *self, char *name)
|
||||
{
|
||||
if (BSTR_EQ(name, "__members__")) return Py_BuildValue("[]");
|
||||
else return Py_FindMethod( BPy_IDGroup_methods, ( PyObject * ) self, name );;
|
||||
}
|
||||
|
||||
PyObject *BPy_IDGroup_setattr(BPy_IDProperty *self, PyObject *val, char *name)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
PyObject *BPy_IDGroup_SpawnIterator(BPy_IDProperty *self)
|
||||
{
|
||||
BPy_IDGroup_Iter *iter = PyObject_New(BPy_IDGroup_Iter, &IDGroup_Iter_Type);
|
||||
iter->group = self;
|
||||
iter->cur = self->prop->data.group.first;
|
||||
Py_XINCREF(iter);
|
||||
return (PyObject*) iter;
|
||||
}
|
||||
|
||||
#define Default_Return "expected a string or int, a string plus variable number of additional arguments"
|
||||
PyObject *BPy_IDGroup_NewProperty(BPy_IDProperty *self, PyObject *args)
|
||||
{
|
||||
IDProperty *prop = NULL;
|
||||
IDPropertyTemplate val = {0};
|
||||
PyObject *pyob, *pyprop=NULL;
|
||||
char *name;
|
||||
int nargs;
|
||||
long type=0;
|
||||
|
||||
/*the arguments required differs depending on the ID type. so we read
|
||||
the first argument first before doing anything else. */
|
||||
nargs = PySequence_Size(args);
|
||||
if (nargs < 2) {
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
Default_Return);
|
||||
}
|
||||
pyob = PyTuple_GET_ITEM(args, 0);
|
||||
|
||||
/*we got a string instead of a type number as argument.*/
|
||||
if (PyString_Check(pyob)) {
|
||||
char *st = PyString_AsString(pyob);
|
||||
if (BSTR_EQ(st, "String")) type = IDP_STRING;
|
||||
else if (BSTR_EQ(st, "Group")) type = IDP_GROUP;
|
||||
else if (BSTR_EQ(st, "Int")) type = IDP_INT;
|
||||
else if (BSTR_EQ(st, "Float")) type = IDP_FLOAT;
|
||||
else if (BSTR_EQ(st, "Array")) type = IDP_ARRAY;
|
||||
else return EXPP_ReturnPyObjError( PyExc_TypeError, "invalid id property type!");
|
||||
} else {
|
||||
if (!PyNumber_Check(pyob)) {
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError, Default_Return);
|
||||
}
|
||||
pyob = PyNumber_Int(pyob);
|
||||
if (pyob == NULL) {
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError, Default_Return);
|
||||
}
|
||||
type = PyInt_AsLong(pyob);
|
||||
Py_XDECREF(pyob);
|
||||
}
|
||||
|
||||
pyob = PyTuple_GET_ITEM(args, 1);
|
||||
if (!PyString_Check(pyob))
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError, Default_Return);
|
||||
|
||||
name = PyString_AsString(pyob);
|
||||
//printf("name: %p %s\n", name, name);
|
||||
//printf("group name: %s\n", self->prop->name);
|
||||
switch (type) {
|
||||
case IDP_STRING:
|
||||
{
|
||||
if (nargs > 3) {
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"expected a string or an int, a string and optionally a string");
|
||||
}
|
||||
if (nargs == 3) {
|
||||
val.str = PyString_AsString(PyTuple_GET_ITEM(args, 2));
|
||||
} else val.str = NULL;
|
||||
|
||||
prop = IDP_New(IDP_STRING, val, name);
|
||||
break;
|
||||
}
|
||||
case IDP_GROUP:
|
||||
if (nargs != 2) {
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"expected a string or an int, and a string");
|
||||
}
|
||||
prop = IDP_New(IDP_GROUP, val, name);
|
||||
break;
|
||||
case IDP_INT:
|
||||
if (nargs != 2 && nargs != 3)
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"expected a string or an int, a string and optionally an int");
|
||||
val.i = 0;
|
||||
if (nargs == 3) {
|
||||
pyob = PyTuple_GET_ITEM(args, 2);
|
||||
if (!PyNumber_Check(pyob))
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"expected a string or an int, a string and optionally an int");
|
||||
pyob = PyNumber_Int(pyob);
|
||||
if (pyob == NULL)
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"expected a string or an int, a string and optionally an int");
|
||||
val.i = (int) PyInt_AsLong(pyob);
|
||||
Py_XDECREF(pyob);
|
||||
}
|
||||
prop = IDP_New(IDP_INT, val, name);
|
||||
break;
|
||||
case IDP_FLOAT:
|
||||
if (nargs != 2 && nargs != 3)
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"expected a string or an int, a string and optionally an int");
|
||||
val.i = 0;
|
||||
if (nargs == 3) {
|
||||
pyob = PyTuple_GET_ITEM(args, 2);
|
||||
if (!PyNumber_Check(pyob))
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"expected a string or an int, a string and optionally an int");
|
||||
pyob = PyNumber_Float(pyob);
|
||||
if (pyob == NULL)
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"expected a string or an int, a string and optionally an int");
|
||||
val.f = (int) PyFloat_AS_DOUBLE(pyob);
|
||||
Py_XDECREF(pyob);
|
||||
}
|
||||
prop = IDP_New(IDP_FLOAT, val, name);
|
||||
break;
|
||||
case IDP_ARRAY:
|
||||
{
|
||||
int arrtype=0;
|
||||
if (nargs != 4 && !PyNumber_Check(PyTuple_GET_ITEM(args, 2))
|
||||
&& (!PyNumber_Check(PyTuple_GET_ITEM(args, 3)) || !PyString_Check(PyTuple_GET_ITEM(args, 3))))
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"expected a string or an int, a string, an int or a string, and an int");
|
||||
|
||||
pyob = PyTuple_GET_ITEM(args, 2);
|
||||
if (PyNumber_Check(pyob)) {
|
||||
pyob = PyNumber_Int(pyob);
|
||||
if (pyob == NULL)
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"expected a string or an int, a string, an int or a string, and an int");
|
||||
|
||||
arrtype = (int)PyInt_AsLong(pyob);
|
||||
Py_XDECREF(pyob);
|
||||
if (arrtype != IDP_FLOAT && arrtype != IDP_INT)
|
||||
EXPP_ReturnPyObjError( PyExc_TypeError, "invalid array type constant");
|
||||
} else {
|
||||
char *st = PyString_AsString(pyob);
|
||||
if (BSTR_EQ(st, "Float")) arrtype = IDP_FLOAT;
|
||||
else if (BSTR_EQ(st, "Int")) arrtype = IDP_INT;
|
||||
else return EXPP_ReturnPyObjError( PyExc_TypeError, "invalid array type");
|
||||
}
|
||||
|
||||
if (arrtype == 0) return NULL;
|
||||
|
||||
val.array.type = arrtype;
|
||||
pyob = PyNumber_Int(PyTuple_GET_ITEM(args, 3));
|
||||
if (pyob == NULL)
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"expected a string or an int, a string, an int or a string, and an int");
|
||||
|
||||
val.array.len = (int)PyInt_AsLong(pyob);
|
||||
|
||||
if (val.array.len <= 0)
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"array len must be greater then zero!");
|
||||
|
||||
prop = IDP_New(IDP_ARRAY, val, name);
|
||||
if (!prop) return EXPP_ReturnPyObjError( PyExc_RuntimeError,
|
||||
"error creating array!");
|
||||
break;
|
||||
}
|
||||
default:
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"invalid id property type");
|
||||
}
|
||||
|
||||
IDP_AddToGroup(self->prop, prop);
|
||||
pyprop = BPy_Wrap_IDProperty(self->id, prop);
|
||||
//Py_XINCREF(pyprop);
|
||||
return pyprop;
|
||||
}
|
||||
|
||||
#undef Default_Return
|
||||
|
||||
PyObject *BPy_IDGroup_DeleteProperty(BPy_IDProperty *self, PyObject *args)
|
||||
{
|
||||
IDProperty *loop;
|
||||
PyObject *ob;
|
||||
char *name;
|
||||
int nargs;
|
||||
|
||||
nargs = PySequence_Size(args);
|
||||
if (nargs != 1)
|
||||
return EXPP_ReturnPyObjError( PyExc_TypeError,
|
||||
"expected a string or IDProperty object");
|
||||
|
||||
ob = PyTuple_GET_ITEM(args, 0);
|
||||
if (PyString_Check(ob)) {
|
||||
name = PyString_AsString(ob);
|
||||
for (loop=self->prop->data.group.first; loop; loop=loop->next) {
|
||||
if (BSTR_EQ(name, loop->name)) {
|
||||
IDP_RemFromGroup(self->prop, loop);
|
||||
IDP_FreeProperty(loop);
|
||||
MEM_freeN(loop);
|
||||
Py_INCREF( Py_None );
|
||||
return Py_None;
|
||||
}
|
||||
}
|
||||
return EXPP_ReturnPyObjError( PyExc_AttributeError,
|
||||
"IDProperty not in group!");
|
||||
|
||||
} else if (PyObject_TypeCheck(ob, &IDProperty_Type)) {
|
||||
for (loop=self->prop->data.group.first; loop; loop=loop->next) {
|
||||
if (loop == ((BPy_IDProperty*)ob)->prop) {
|
||||
IDP_RemFromGroup(self->prop, loop);
|
||||
IDP_FreeProperty(loop);
|
||||
MEM_freeN(loop);
|
||||
Py_INCREF( Py_None );
|
||||
return Py_None;
|
||||
}
|
||||
}
|
||||
return EXPP_ReturnPyObjError( PyExc_AttributeError,
|
||||
"IDProperty not in group!");
|
||||
}
|
||||
|
||||
return EXPP_ReturnPyObjError( PyExc_AttributeError,
|
||||
"expected a string or IDProperty object");
|
||||
}
|
||||
|
||||
int BPy_IDGroup_Len(BPy_IDArray *self)
|
||||
{
|
||||
return self->prop->len;
|
||||
}
|
||||
|
||||
PyObject *BPy_IDGroup_GetItem(BPy_IDProperty *self, int index)
|
||||
{
|
||||
IDProperty *prop;
|
||||
int i;
|
||||
|
||||
for (prop=self->prop->data.group.first, i=0; prop; prop=prop->next, i++) {
|
||||
if (i == index) return BPy_Wrap_IDProperty(self->id, prop);
|
||||
}
|
||||
|
||||
return EXPP_ReturnPyObjError( PyExc_IndexError,
|
||||
"index out of range!");
|
||||
}
|
||||
|
||||
static PySequenceMethods BPy_IDGroup_Seq = {
|
||||
(inquiry) BPy_IDGroup_Len, /* inquiry sq_length */
|
||||
0, /* binaryfunc sq_concat */
|
||||
0, /* intargfunc sq_repeat */
|
||||
(intargfunc)BPy_IDGroup_GetItem, /* intargfunc sq_item */
|
||||
0, /* intintargfunc sq_slice */
|
||||
0, /* intobjargproc sq_ass_item */
|
||||
0, /* intintobjargproc sq_ass_slice */
|
||||
0, /* objobjproc sq_contains */
|
||||
/* Added in release 2.0 */
|
||||
0, /* binaryfunc sq_inplace_concat */
|
||||
0, /* intargfunc sq_inplace_repeat */
|
||||
};
|
||||
|
||||
PyTypeObject IDGroup_Type = {
|
||||
PyObject_HEAD_INIT( NULL ) /* required py macro */
|
||||
0, /* ob_size */
|
||||
/* For printing, in format "<module>.<name>" */
|
||||
"Blender IDGroup", /* char *tp_name; */
|
||||
sizeof( BPy_IDProperty ), /* int tp_basicsize; */
|
||||
0, /* tp_itemsize; For allocation */
|
||||
|
||||
/* Methods to implement standard operations */
|
||||
|
||||
( destructor ) IDGroup_dealloc,/* destructor tp_dealloc; */
|
||||
NULL, /* printfunc tp_print; */
|
||||
( getattrfunc ) BPy_IDGroup_getattr, /* getattrfunc tp_getattr; */
|
||||
( setattrfunc ) BPy_IDGroup_setattr, /* setattrfunc tp_setattr; */
|
||||
NULL, /* cmpfunc tp_compare; */
|
||||
( reprfunc ) IDGroup_repr, /* reprfunc tp_repr; */
|
||||
|
||||
/* Method suites for standard classes */
|
||||
|
||||
NULL, /* PyNumberMethods *tp_as_number; */
|
||||
&BPy_IDGroup_Seq, /* PySequenceMethods *tp_as_sequence; */
|
||||
&BPy_IDProperty_Mapping, /* PyMappingMethods *tp_as_mapping; */
|
||||
|
||||
/* More standard operations (here for binary compatibility) */
|
||||
|
||||
NULL, /* hashfunc tp_hash; */
|
||||
NULL, /* ternaryfunc tp_call; */
|
||||
NULL, /* reprfunc tp_str; */
|
||||
NULL, /* getattrofunc tp_getattro; */
|
||||
NULL, /* 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 */
|
||||
( getiterfunc ) BPy_IDGroup_SpawnIterator, /* getiterfunc tp_iter; */
|
||||
NULL, /* iternextfunc tp_iternext; */
|
||||
|
||||
/*** Attribute descriptor and subclassing stuff ***/
|
||||
BPy_IDGroup_methods, /* 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; */
|
||||
};
|
||||
26
source/blender/python/api2_2x/IDProp.h
Normal file
26
source/blender/python/api2_2x/IDProp.h
Normal file
@@ -0,0 +1,26 @@
|
||||
#include <Python.h>
|
||||
|
||||
struct ID;
|
||||
struct IDProperty;
|
||||
struct BPy_IDGroup_Iter;
|
||||
|
||||
typedef struct BPy_IDProperty {
|
||||
PyObject_VAR_HEAD
|
||||
struct ID *id;
|
||||
struct IDProperty *prop;
|
||||
PyObject *data_wrap;
|
||||
} BPy_IDProperty;
|
||||
|
||||
typedef struct BPy_IDArray {
|
||||
PyObject_VAR_HEAD
|
||||
struct ID *id;
|
||||
struct IDProperty *prop;
|
||||
} BPy_IDArray;
|
||||
|
||||
typedef struct BPy_IDGroup_Iter {
|
||||
PyObject_VAR_HEAD
|
||||
BPy_IDProperty *group;
|
||||
struct IDProperty *cur;
|
||||
} BPy_IDGroup_Iter;
|
||||
|
||||
PyObject *BPy_Wrap_IDProperty(struct ID *id, struct IDProperty *prop);
|
||||
@@ -41,6 +41,7 @@
|
||||
#include "BKE_library.h"
|
||||
#include "BKE_material.h"
|
||||
#include "BKE_texture.h"
|
||||
#include "BKE_idprop.h"
|
||||
#include "MEM_guardedalloc.h"
|
||||
#include "BLI_blenlib.h"
|
||||
#include "BSE_editipo.h"
|
||||
@@ -52,6 +53,7 @@
|
||||
#include "Ipo.h"
|
||||
#include "Group.h"
|
||||
#include "gen_utils.h"
|
||||
#include "IDProp.h"
|
||||
|
||||
/*****************************************************************************/
|
||||
/* Python BPy_Material defaults: */
|
||||
@@ -602,6 +604,7 @@ static PyObject *Material_clearScriptLinks(BPy_Material *self, PyObject *args);
|
||||
|
||||
static PyObject *Material_insertIpoKey( BPy_Material * self, PyObject * args );
|
||||
static PyObject *Material_copy( BPy_Material * self );
|
||||
static PyObject *Material_getProperties( BPy_Material * self );
|
||||
|
||||
|
||||
/*****************************************************************************/
|
||||
@@ -609,6 +612,8 @@ static PyObject *Material_copy( BPy_Material * self );
|
||||
/*****************************************************************************/
|
||||
static PyMethodDef BPy_Material_methods[] = {
|
||||
/* name, method, flags, doc */
|
||||
{"getProperties", ( PyCFunction) Material_getProperties, METH_NOARGS,
|
||||
"() Return Material's ID Properties"},
|
||||
{"getName", ( PyCFunction ) Material_getName, METH_NOARGS,
|
||||
"() - Return Material's name"},
|
||||
{"getIpo", ( PyCFunction ) Material_getIpo, METH_NOARGS,
|
||||
@@ -1080,6 +1085,8 @@ static PyGetSetDef BPy_Material_getseters[] = {
|
||||
(getter)Material_getUsers, (setter)NULL,
|
||||
"Number of material users",
|
||||
NULL},
|
||||
{"properties", (getter) Material_getProperties, (setter)NULL,
|
||||
"Get material's ID properties"},
|
||||
{NULL,NULL,NULL,NULL,NULL} /* Sentinel */
|
||||
};
|
||||
|
||||
@@ -1280,6 +1287,12 @@ Material *GetMaterialByName( char *name )
|
||||
/* Python BPy_Material methods: */
|
||||
/*****************************************************************************/
|
||||
|
||||
static PyObject *Material_getProperties( BPy_Material * self )
|
||||
{
|
||||
/*sanity check, we set parent property type to Group here*/
|
||||
return BPy_Wrap_IDProperty((ID*)self->material, IDP_GetProperties((ID*)self->material, 1));
|
||||
}
|
||||
|
||||
static PyObject *Material_getIpo( BPy_Material * self )
|
||||
{
|
||||
Ipo *ipo = self->material->ipo;
|
||||
|
||||
@@ -66,6 +66,7 @@ struct rctf;
|
||||
#include "BKE_scene.h"
|
||||
#include "BKE_nla.h"
|
||||
#include "BKE_material.h"
|
||||
#include "BKE_idprop.h"
|
||||
|
||||
#include "BSE_editipo.h"
|
||||
#include "BSE_edit.h"
|
||||
@@ -114,6 +115,7 @@ struct rctf;
|
||||
#include "gen_utils.h"
|
||||
#include "EXPP_interface.h"
|
||||
#include "BIF_editkey.h"
|
||||
#include "IDProp.h"
|
||||
|
||||
/* Defines for insertIpoKey */
|
||||
|
||||
@@ -326,6 +328,7 @@ struct PyMethodDef M_Object_methods[] = {
|
||||
static int setupSB(Object* ob); /*Make sure Softbody Pointer is initialized */
|
||||
static int setupPI(Object* ob);
|
||||
|
||||
static PyObject *Object_GetProperties(BPy_Object * self);
|
||||
static PyObject *Object_buildParts( BPy_Object * self );
|
||||
static PyObject *Object_clearIpo( BPy_Object * self );
|
||||
static PyObject *Object_clrParent( BPy_Object * self, PyObject * args );
|
||||
@@ -750,6 +753,8 @@ works only if self and the object specified are of the same type."},
|
||||
"() - Insert a Shape Key in the current object"},
|
||||
{"__copy__", ( PyCFunction ) Object_copy, METH_NOARGS,
|
||||
"() - Return a copy of this object."},
|
||||
{"getProperties", ( PyCFunction ) Object_GetProperties, METH_NOARGS,
|
||||
"() return a reference to the ID properties associated with this object."},
|
||||
{NULL, NULL, 0, NULL}
|
||||
};
|
||||
|
||||
@@ -982,6 +987,12 @@ static PyObject *M_Object_Duplicate( PyObject * self_unused,
|
||||
/* Python BPy_Object methods: */
|
||||
/*****************************************************************************/
|
||||
|
||||
static PyObject *Object_GetProperties(BPy_Object * self)
|
||||
{
|
||||
return BPy_Wrap_IDProperty((ID*)self->object, IDP_GetProperties((ID*)self->object, 1));
|
||||
|
||||
}
|
||||
|
||||
static PyObject *Object_buildParts( BPy_Object * self )
|
||||
{
|
||||
build_particle_system( self->object );
|
||||
@@ -4983,7 +4994,8 @@ static PyGetSetDef BPy_Object_getseters[] = {
|
||||
(getter)Object_getType, (setter)NULL,
|
||||
"String describing Object type",
|
||||
NULL},
|
||||
|
||||
{"properties", (getter)Object_GetProperties, (setter)NULL,
|
||||
"Get the ID properties associated with this object"},
|
||||
{NULL,NULL,NULL,NULL,NULL} /* Sentinel */
|
||||
};
|
||||
|
||||
|
||||
65
source/blender/python/api2_2x/doc/IDProp.py
Normal file
65
source/blender/python/api2_2x/doc/IDProp.py
Normal file
@@ -0,0 +1,65 @@
|
||||
class IDProperty:
|
||||
"""
|
||||
The IDProperty wrapper type
|
||||
===========================
|
||||
@ivar name: the name of the property
|
||||
@ivar type: the property type (is read-only)
|
||||
@ivar data: the property's data.
|
||||
"""
|
||||
|
||||
class IDGroup:
|
||||
"""
|
||||
The IDGroup wrapper type
|
||||
========================
|
||||
This type supports both iteration and the []
|
||||
operator to get child ID properties.
|
||||
|
||||
You can also add new properties using the [] operator.
|
||||
For example:
|
||||
|
||||
group['a float!'] = 0.0
|
||||
group['an int!'] = 0
|
||||
group['a string!'] = "hi!"
|
||||
group['an array!'] = [0, 0, 1.0, 0] #note that any floats in the list
|
||||
#makes the whole list a float array.
|
||||
group['a subgroup!] = {"float": 0.0, "an int": 1.0, "an array": [1, 2], \
|
||||
"another subgroup": {"a": 0.0, "str": "bleh"}}
|
||||
|
||||
you also do del group['item']
|
||||
"""
|
||||
|
||||
def newProperty(type, name, array_type="Float", val=""):
|
||||
"""
|
||||
This function creates a new child ID property in the group.
|
||||
@type type: an int or a string
|
||||
@param type: The ID property type. Can be:
|
||||
"String" or Blender.IDPropTypes['String']
|
||||
"Int" or Blender.IDPropTypes['Int']
|
||||
"Float" or Blender.IDPropTypes['Float']
|
||||
"Array" or Blender.IDPropTypes['Array']
|
||||
"Group" or Blender.IDPropTypes['Group']
|
||||
"""
|
||||
|
||||
def deleteProperty(prop):
|
||||
"""
|
||||
deletes a property, takes either a name or a reference
|
||||
as an argument.
|
||||
"""
|
||||
|
||||
class IDArray:
|
||||
"""
|
||||
The IDArray wrapper type
|
||||
========================
|
||||
|
||||
@ivar type: returns the type of the array, can be either IDP_Int or IDP_Float
|
||||
"""
|
||||
|
||||
def __getitem__(self):
|
||||
pass
|
||||
|
||||
def __setitem__(self):
|
||||
pass
|
||||
|
||||
def __len__(self):
|
||||
pass
|
||||
|
||||
Reference in New Issue
Block a user