archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
b347c4e9ca896c7f1149502962add1163db1e82c
blender-archive/source/blender/python/intern/bpy_props.c
Campbell Barton 525364be31 Cleanup: reduce indirect DNA header inclusion 
Remove DNA headers, using forward declarations where possible.

Also removed duplicate header, header including it's self
and unnecessary inclusion of libc system headers from BKE header.
2020-12-15 12:34:14 +11:00

3674 lines
107 KiB
C
Raw Blame History

/*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
/** \file
* \ingroup pythonintern
*
* This file defines 'bpy.props' module used so scripts can define their own
* rna properties for use with python operators or adding new properties to
* existing blender types.
*/
/* Future-proof, See https://docs.python.org/3/c-api/arg.html#strings-and-buffers */
#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include "RNA_types.h"
#include "BLI_utildefines.h"
#include "bpy_capi_utils.h"
#include "bpy_props.h"
#include "bpy_rna.h"
#include "BKE_idprop.h"
#include "RNA_access.h"
#include "RNA_define.h" /* for defining our own rna */
#include "RNA_enum_types.h"
#include "MEM_guardedalloc.h"
#include "DNA_ID.h" /* MAX_IDPROP_NAME */
#include "../generic/py_capi_utils.h"
/* initial definition of callback slots we'll probably have more than 1 */
enum {
BPY_DATA_CB_SLOT_UPDATE = 0,
BPY_DATA_CB_SLOT_GET = 1,
BPY_DATA_CB_SLOT_SET = 2,
BPY_DATA_CB_SLOT_POLL = 3,
BPY_DATA_CB_SLOT_SIZE = 4,
};
static const EnumPropertyItem property_flag_items[] = {
{PROP_HIDDEN, "HIDDEN", 0, "Hidden", ""},
{PROP_SKIP_SAVE, "SKIP_SAVE", 0, "Skip Save", ""},
{PROP_ANIMATABLE, "ANIMATABLE", 0, "Animatable", ""},
{PROP_LIB_EXCEPTION, "LIBRARY_EDITABLE", 0, "Library Editable", ""},
{PROP_PROPORTIONAL, "PROPORTIONAL", 0, "Adjust values proportionally to eachother", ""},
{PROP_TEXTEDIT_UPDATE,
"TEXTEDIT_UPDATE",
0,
"Update on every keystroke in textedit 'mode'",
""},
{0, NULL, 0, NULL, NULL},
};
#define BPY_PROPDEF_OPTIONS_DOC \
" :arg options: Enumerator in ['HIDDEN', 'SKIP_SAVE', 'ANIMATABLE', 'LIBRARY_EDITABLE', " \
"'PROPORTIONAL'," \
"'TEXTEDIT_UPDATE'].\n" \
" :type options: set\n"
static const EnumPropertyItem property_flag_enum_items[] = {
{PROP_HIDDEN, "HIDDEN", 0, "Hidden", ""},
{PROP_SKIP_SAVE, "SKIP_SAVE", 0, "Skip Save", ""},
{PROP_ANIMATABLE, "ANIMATABLE", 0, "Animatable", ""},
{PROP_LIB_EXCEPTION, "LIBRARY_EDITABLE", 0, "Library Editable", ""},
{PROP_ENUM_FLAG, "ENUM_FLAG", 0, "Enum Flag", ""},
{0, NULL, 0, NULL, NULL},
};
#define BPY_PROPDEF_OPTIONS_ENUM_DOC \
" :arg options: Enumerator in ['HIDDEN', 'SKIP_SAVE', 'ANIMATABLE', 'ENUM_FLAG', " \
"'LIBRARY_EDITABLE'].\n" \
" :type options: set\n"
static const EnumPropertyItem property_flag_override_items[] = {
{PROPOVERRIDE_OVERRIDABLE_LIBRARY,
"LIBRARY_OVERRIDABLE",
0,
"Library Overridable",
"Make that property editable in library overrides of linked data-blocks"},
{0, NULL, 0, NULL, NULL},
};
#define BPY_PROPDEF_OPTIONS_OVERRIDE_DOC \
" :arg override: Enumerator in ['LIBRARY_OVERRIDABLE'].\n" \
" :type override: set\n"
static const EnumPropertyItem property_flag_override_collection_items[] = {
{PROPOVERRIDE_OVERRIDABLE_LIBRARY,
"LIBRARY_OVERRIDABLE",
0,
"Library Overridable",
"Make that property editable in library overrides of linked data-blocks"},
{PROPOVERRIDE_NO_PROP_NAME,
"NO_PROPERTY_NAME",
0,
"No Name",
"Do not use the names of the items, only their indices in the collection"},
{PROPOVERRIDE_LIBRARY_INSERTION,
"USE_INSERTION",
0,
"Use Insertion",
"Allow users to add new items in that collection in library overrides"},
{0, NULL, 0, NULL, NULL},
};
#define BPY_PROPDEF_OPTIONS_OVERRIDE_COLLECTION_DOC \
" :arg override: Enumerator in ['LIBRARY_OVERRIDABLE', 'NO_PROPERTY_NAME', " \
"'USE_INSERTION'].\n" \
" :type override: set\n"
/* subtypes */
/* Keep in sync with RNA_types.h PropertySubType and rna_rna.c's rna_enum_property_subtype_items */
static const EnumPropertyItem property_subtype_string_items[] = {
{PROP_FILEPATH, "FILE_PATH", 0, "File Path", ""},
{PROP_DIRPATH, "DIR_PATH", 0, "Directory Path", ""},
{PROP_FILENAME, "FILE_NAME", 0, "Filename", ""},
{PROP_BYTESTRING, "BYTE_STRING", 0, "Byte String", ""},
{PROP_PASSWORD, "PASSWORD", 0, "Password", "A string that is displayed hidden ('********')"},
{PROP_NONE, "NONE", 0, "None", ""},
{0, NULL, 0, NULL, NULL},
};
#define BPY_PROPDEF_SUBTYPE_STRING_DOC \
" :arg subtype: Enumerator in ['FILE_PATH', 'DIR_PATH', 'FILE_NAME', 'BYTE_STRING', " \
"'PASSWORD', 'NONE'].\n" \
" :type subtype: string\n"
static const EnumPropertyItem property_subtype_number_items[] = {
{PROP_PIXEL, "PIXEL", 0, "Pixel", ""},
{PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned", ""},
{PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", ""},
{PROP_FACTOR, "FACTOR", 0, "Factor", ""},
{PROP_ANGLE, "ANGLE", 0, "Angle", ""},
{PROP_TIME, "TIME", 0, "Time", ""},
{PROP_DISTANCE, "DISTANCE", 0, "Distance", ""},
{PROP_DISTANCE_CAMERA, "DISTANCE_CAMERA", 0, "Camera Distance", ""},
{PROP_POWER, "POWER", 0, "Power", ""},
{PROP_TEMPERATURE, "TEMPERATURE", 0, "Temperature", ""},
{PROP_NONE, "NONE", 0, "None", ""},
{0, NULL, 0, NULL, NULL},
};
#define BPY_PROPDEF_SUBTYPE_NUMBER_DOC \
" :arg subtype: Enumerator in ['PIXEL', 'UNSIGNED', 'PERCENTAGE', 'FACTOR', 'ANGLE', " \
"'TIME', 'DISTANCE', 'DISTANCE_CAMERA', 'POWER', 'TEMPERATURE', 'NONE'].\n" \
" :type subtype: string\n"
static const EnumPropertyItem property_subtype_array_items[] = {
{PROP_COLOR, "COLOR", 0, "Color", ""},
{PROP_TRANSLATION, "TRANSLATION", 0, "Translation", ""},
{PROP_DIRECTION, "DIRECTION", 0, "Direction", ""},
{PROP_VELOCITY, "VELOCITY", 0, "Velocity", ""},
{PROP_ACCELERATION, "ACCELERATION", 0, "Acceleration", ""},
{PROP_MATRIX, "MATRIX", 0, "Matrix", ""},
{PROP_EULER, "EULER", 0, "Euler", ""},
{PROP_QUATERNION, "QUATERNION", 0, "Quaternion", ""},
{PROP_AXISANGLE, "AXISANGLE", 0, "Axis Angle", ""},
{PROP_XYZ, "XYZ", 0, "XYZ", ""},
{PROP_XYZ_LENGTH, "XYZ_LENGTH", 0, "XYZ Length", ""},
{PROP_COLOR_GAMMA, "COLOR_GAMMA", 0, "Color Gamma", ""},
{PROP_COORDS, "COORDINATES", 0, "Vector Coordinates", ""},
{PROP_LAYER, "LAYER", 0, "Layer", ""},
{PROP_LAYER_MEMBER, "LAYER_MEMBER", 0, "Layer Member", ""},
{PROP_NONE, "NONE", 0, "None", ""},
{0, NULL, 0, NULL, NULL},
};
#define BPY_PROPDEF_SUBTYPE_ARRAY_DOC \
" :arg subtype: Enumerator in ['COLOR', 'TRANSLATION', 'DIRECTION', " \
"'VELOCITY', 'ACCELERATION', 'MATRIX', 'EULER', 'QUATERNION', 'AXISANGLE', " \
"'XYZ', 'XYZ_LENGTH', 'COLOR_GAMMA', 'COORDINATES', 'LAYER', 'LAYER_MEMBER', 'NONE'].\n" \
" :type subtype: string\n"
/* PyObject's */
static PyObject *pymeth_BoolProperty = NULL;
static PyObject *pymeth_BoolVectorProperty = NULL;
static PyObject *pymeth_IntProperty = NULL;
static PyObject *pymeth_IntVectorProperty = NULL;
static PyObject *pymeth_FloatProperty = NULL;
static PyObject *pymeth_FloatVectorProperty = NULL;
static PyObject *pymeth_StringProperty = NULL;
static PyObject *pymeth_EnumProperty = NULL;
static PyObject *pymeth_PointerProperty = NULL;
static PyObject *pymeth_CollectionProperty = NULL;
static PyObject *pymeth_RemoveProperty = NULL;
static PyObject *pyrna_struct_as_instance(PointerRNA *ptr)
{
PyObject *self = NULL;
/* first get self */
/* operators can store their own instance for later use */
if (ptr->data) {
void **instance = RNA_struct_instance(ptr);
if (instance) {
if (*instance) {
self = *instance;
Py_INCREF(self);
}
}
}
/* in most cases this will run */
if (self == NULL) {
self = pyrna_struct_CreatePyObject(ptr);
}
return self;
}
static void bpy_prop_assign_flag(PropertyRNA *prop, const int flag)
{
const int flag_mask = ((PROP_ANIMATABLE) & ~flag);
if (flag) {
RNA_def_property_flag(prop, flag);
}
if (flag_mask) {
RNA_def_property_clear_flag(prop, flag_mask);
}
}
static void bpy_prop_assign_flag_override(PropertyRNA *prop, const int flag_override)
{
RNA_def_property_override_flag(prop, flag_override);
}
/* operators and classes use this so it can store the args given but defer
* running it until the operator runs where these values are used to setup
* the default args for that operator instance */
static PyObject *bpy_prop_deferred_return(PyObject *func, PyObject *kw)
{
PyObject *ret = PyTuple_New(2);
PyTuple_SET_ITEM(ret, 0, func);
Py_INCREF(func);
if (kw == NULL) {
kw = PyDict_New();
}
else {
Py_INCREF(kw);
}
PyTuple_SET_ITEM(ret, 1, kw);
return ret;
}
/* callbacks */
static void bpy_prop_update_cb(struct bContext *C,
struct PointerRNA *ptr,
struct PropertyRNA *prop)
{
PyGILState_STATE gilstate;
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
const bool is_write_ok = pyrna_write_check();
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
bpy_context_set(C, &gilstate);
py_func = py_data[BPY_DATA_CB_SLOT_UPDATE];
args = PyTuple_New(2);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
PyTuple_SET_ITEM(args, 1, (PyObject *)bpy_context_module);
Py_INCREF(bpy_context_module);
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
}
else {
if (ret != Py_None) {
PyErr_SetString(PyExc_ValueError, "the return value must be None");
PyC_Err_PrintWithFunc(py_func);
}
Py_DECREF(ret);
}
bpy_context_clear(C, &gilstate);
if (!is_write_ok) {
pyrna_write_set(false);
}
}
static bool bpy_prop_boolean_get_cb(struct PointerRNA *ptr, struct PropertyRNA *prop)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
bool value;
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_GET];
args = PyTuple_New(1);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
value = false;
}
else {
const int value_i = PyC_Long_AsBool(ret);
if (value_i == -1 && PyErr_Occurred()) {
PyC_Err_PrintWithFunc(py_func);
value = false;
}
else {
value = (bool)value_i;
}
Py_DECREF(ret);
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
return value;
}
static void bpy_prop_boolean_set_cb(struct PointerRNA *ptr, struct PropertyRNA *prop, bool value)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_SET];
args = PyTuple_New(2);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
PyTuple_SET_ITEM(args, 1, PyBool_FromLong(value));
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
}
else {
if (ret != Py_None) {
PyErr_SetString(PyExc_ValueError, "the return value must be None");
PyC_Err_PrintWithFunc(py_func);
}
Py_DECREF(ret);
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
}
static bool bpy_prop_poll_cb(struct PointerRNA *self,
PointerRNA candidate,
struct PropertyRNA *prop)
{
PyObject *py_self;
PyObject *py_candidate;
PyObject *py_func;
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *args;
PyObject *ret;
bool result;
const int is_write_ok = pyrna_write_check();
const PyGILState_STATE gilstate = PyGILState_Ensure();
BLI_assert(self != NULL);
py_self = pyrna_struct_as_instance(self);
py_candidate = pyrna_struct_as_instance(&candidate);
py_func = py_data[BPY_DATA_CB_SLOT_POLL];
if (!is_write_ok) {
pyrna_write_set(true);
}
args = PyTuple_New(2);
PyTuple_SET_ITEM(args, 0, py_self);
PyTuple_SET_ITEM(args, 1, py_candidate);
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
result = false;
}
else {
result = PyObject_IsTrue(ret);
Py_DECREF(ret);
}
PyGILState_Release(gilstate);
if (!is_write_ok) {
pyrna_write_set(false);
}
return result;
}
static void bpy_prop_boolean_array_get_cb(struct PointerRNA *ptr,
struct PropertyRNA *prop,
bool *values)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
int i, len = RNA_property_array_length(ptr, prop);
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_GET];
args = PyTuple_New(1);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
for (i = 0; i < len; i++) {
values[i] = false;
}
}
else {
if (PyC_AsArray(values, ret, len, &PyBool_Type, false, "BoolVectorProperty get") == -1) {
PyC_Err_PrintWithFunc(py_func);
for (i = 0; i < len; i++) {
values[i] = false;
}
/* PyC_AsArray decrements refcount internally on error */
}
else {
Py_DECREF(ret);
}
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
}
static void bpy_prop_boolean_array_set_cb(struct PointerRNA *ptr,
struct PropertyRNA *prop,
const bool *values)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyObject *py_values;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
const int len = RNA_property_array_length(ptr, prop);
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_SET];
args = PyTuple_New(2);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
py_values = PyC_Tuple_PackArray_Bool(values, len);
PyTuple_SET_ITEM(args, 1, py_values);
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
}
else {
if (ret != Py_None) {
PyErr_SetString(PyExc_ValueError, "the return value must be None");
PyC_Err_PrintWithFunc(py_func);
}
Py_DECREF(ret);
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
}
static int bpy_prop_int_get_cb(struct PointerRNA *ptr, struct PropertyRNA *prop)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
int value;
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_GET];
args = PyTuple_New(1);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
value = 0.0f;
}
else {
value = PyC_Long_AsI32(ret);
if (value == -1 && PyErr_Occurred()) {
PyC_Err_PrintWithFunc(py_func);
value = 0;
}
Py_DECREF(ret);
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
return value;
}
static void bpy_prop_int_set_cb(struct PointerRNA *ptr, struct PropertyRNA *prop, int value)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_SET];
args = PyTuple_New(2);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
PyTuple_SET_ITEM(args, 1, PyLong_FromLong(value));
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
}
else {
if (ret != Py_None) {
PyErr_SetString(PyExc_ValueError, "the return value must be None");
PyC_Err_PrintWithFunc(py_func);
}
Py_DECREF(ret);
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
}
static void bpy_prop_int_array_get_cb(struct PointerRNA *ptr,
struct PropertyRNA *prop,
int *values)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
int i, len = RNA_property_array_length(ptr, prop);
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_GET];
args = PyTuple_New(1);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
for (i = 0; i < len; i++) {
values[i] = 0;
}
}
else {
if (PyC_AsArray(values, ret, len, &PyLong_Type, false, "IntVectorProperty get") == -1) {
PyC_Err_PrintWithFunc(py_func);
for (i = 0; i < len; i++) {
values[i] = 0;
}
/* PyC_AsArray decrements refcount internally on error */
}
else {
Py_DECREF(ret);
}
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
}
static void bpy_prop_int_array_set_cb(struct PointerRNA *ptr,
struct PropertyRNA *prop,
const int *values)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyObject *py_values;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
const int len = RNA_property_array_length(ptr, prop);
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_SET];
args = PyTuple_New(2);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
py_values = PyC_Tuple_PackArray_I32(values, len);
PyTuple_SET_ITEM(args, 1, py_values);
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
}
else {
if (ret != Py_None) {
PyErr_SetString(PyExc_ValueError, "the return value must be None");
PyC_Err_PrintWithFunc(py_func);
}
Py_DECREF(ret);
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
}
static float bpy_prop_float_get_cb(struct PointerRNA *ptr, struct PropertyRNA *prop)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
float value;
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_GET];
args = PyTuple_New(1);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
value = 0.0f;
}
else {
value = PyFloat_AsDouble(ret);
if (value == -1.0f && PyErr_Occurred()) {
PyC_Err_PrintWithFunc(py_func);
value = 0.0f;
}
Py_DECREF(ret);
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
return value;
}
static void bpy_prop_float_set_cb(struct PointerRNA *ptr, struct PropertyRNA *prop, float value)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_SET];
args = PyTuple_New(2);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
PyTuple_SET_ITEM(args, 1, PyFloat_FromDouble(value));
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
}
else {
if (ret != Py_None) {
PyErr_SetString(PyExc_ValueError, "the return value must be None");
PyC_Err_PrintWithFunc(py_func);
}
Py_DECREF(ret);
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
}
static void bpy_prop_float_array_get_cb(struct PointerRNA *ptr,
struct PropertyRNA *prop,
float *values)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
int i, len = RNA_property_array_length(ptr, prop);
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_GET];
args = PyTuple_New(1);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
for (i = 0; i < len; i++) {
values[i] = 0.0f;
}
}
else {
if (PyC_AsArray(values, ret, len, &PyFloat_Type, false, "FloatVectorProperty get") == -1) {
PyC_Err_PrintWithFunc(py_func);
for (i = 0; i < len; i++) {
values[i] = 0.0f;
}
/* PyC_AsArray decrements refcount internally on error */
}
else {
Py_DECREF(ret);
}
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
}
static void bpy_prop_float_array_set_cb(struct PointerRNA *ptr,
struct PropertyRNA *prop,
const float *values)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyObject *py_values;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
const int len = RNA_property_array_length(ptr, prop);
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_SET];
args = PyTuple_New(2);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
py_values = PyC_Tuple_PackArray_F32(values, len);
PyTuple_SET_ITEM(args, 1, py_values);
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
}
else {
if (ret != Py_None) {
PyErr_SetString(PyExc_ValueError, "the return value must be None");
PyC_Err_PrintWithFunc(py_func);
}
Py_DECREF(ret);
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
}
static void bpy_prop_string_get_cb(struct PointerRNA *ptr, struct PropertyRNA *prop, char *value)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_GET];
args = PyTuple_New(1);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
value[0] = '\0';
}
else if (!PyUnicode_Check(ret)) {
PyErr_Format(
PyExc_TypeError, "return value must be a string, not %.200s", Py_TYPE(ret)->tp_name);
PyC_Err_PrintWithFunc(py_func);
value[0] = '\0';
Py_DECREF(ret);
}
else {
Py_ssize_t length;
const char *buffer = _PyUnicode_AsStringAndSize(ret, &length);
memcpy(value, buffer, length + 1);
Py_DECREF(ret);
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
}
static int bpy_prop_string_length_cb(struct PointerRNA *ptr, struct PropertyRNA *prop)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
int length;
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_GET];
args = PyTuple_New(1);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
length = 0;
}
else if (!PyUnicode_Check(ret)) {
PyErr_Format(
PyExc_TypeError, "return value must be a string, not %.200s", Py_TYPE(ret)->tp_name);
PyC_Err_PrintWithFunc(py_func);
length = 0;
Py_DECREF(ret);
}
else {
Py_ssize_t length_ssize_t = 0;
_PyUnicode_AsStringAndSize(ret, &length_ssize_t);
length = length_ssize_t;
Py_DECREF(ret);
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
return length;
}
static void bpy_prop_string_set_cb(struct PointerRNA *ptr,
struct PropertyRNA *prop,
const char *value)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
PyObject *py_value;
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_SET];
args = PyTuple_New(2);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
py_value = PyUnicode_FromString(value);
if (!py_value) {
PyErr_SetString(PyExc_ValueError, "the return value must be a string");
PyC_Err_PrintWithFunc(py_func);
}
else {
PyTuple_SET_ITEM(args, 1, py_value);
}
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
}
else {
if (ret != Py_None) {
PyErr_SetString(PyExc_ValueError, "the return value must be None");
PyC_Err_PrintWithFunc(py_func);
}
Py_DECREF(ret);
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
}
static int bpy_prop_enum_get_cb(struct PointerRNA *ptr, struct PropertyRNA *prop)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
int value;
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_GET];
args = PyTuple_New(1);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
value = RNA_property_enum_get_default(ptr, prop);
}
else {
value = PyC_Long_AsI32(ret);
if (value == -1 && PyErr_Occurred()) {
PyC_Err_PrintWithFunc(py_func);
value = RNA_property_enum_get_default(ptr, prop);
}
Py_DECREF(ret);
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
return value;
}
static void bpy_prop_enum_set_cb(struct PointerRNA *ptr, struct PropertyRNA *prop, int value)
{
PyObject **py_data = RNA_property_py_data_get(prop);
PyObject *py_func;
PyObject *args;
PyObject *self;
PyObject *ret;
PyGILState_STATE gilstate;
bool use_gil;
const bool is_write_ok = pyrna_write_check();
BLI_assert(py_data != NULL);
if (!is_write_ok) {
pyrna_write_set(true);
}
use_gil = true; /* !PyC_IsInterpreterActive(); */
if (use_gil) {
gilstate = PyGILState_Ensure();
}
py_func = py_data[BPY_DATA_CB_SLOT_SET];
args = PyTuple_New(2);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
PyTuple_SET_ITEM(args, 1, PyLong_FromLong(value));
ret = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (ret == NULL) {
PyC_Err_PrintWithFunc(py_func);
}
else {
if (ret != Py_None) {
PyErr_SetString(PyExc_ValueError, "the return value must be None");
PyC_Err_PrintWithFunc(py_func);
}
Py_DECREF(ret);
}
if (use_gil) {
PyGILState_Release(gilstate);
}
if (!is_write_ok) {
pyrna_write_set(false);
}
}
/* utility function we need for parsing int's in an if statement */
static bool py_long_as_int(PyObject *py_long, int *r_int)
{
if (PyLong_CheckExact(py_long)) {
*r_int = (int)PyLong_AS_LONG(py_long);
return true;
}
return false;
}
#if 0
/* copies orig to buf, then sets orig to buf, returns copy length */
static size_t strswapbufcpy(char *buf, const char **orig)
{
const char *src = *orig;
char *dst = buf;
size_t i = 0;
*orig = buf;
while ((*dst = *src)) {
dst++;
src++;
i++;
}
return i + 1; /* include '\0' */
}
#endif
static int icon_id_from_name(const char *name)
{
const EnumPropertyItem *item;
int id;
if (name[0]) {
for (item = rna_enum_icon_items, id = 0; item->identifier; item++, id++) {
if (STREQ(item->name, name)) {
return item->value;
}
}
}
return 0;
}
static const EnumPropertyItem *enum_items_from_py(PyObject *seq_fast,
PyObject *def,
int *defvalue,
const bool is_enum_flag)
{
EnumPropertyItem *items;
PyObject *item;
const Py_ssize_t seq_len = PySequence_Fast_GET_SIZE(seq_fast);
PyObject **seq_fast_items = PySequence_Fast_ITEMS(seq_fast);
Py_ssize_t totbuf = 0;
int i;
short def_used = 0;
const char *def_string_cmp = NULL;
int def_int_cmp = 0;
if (is_enum_flag) {
if (seq_len > RNA_ENUM_BITFLAG_SIZE) {
PyErr_SetString(PyExc_TypeError,
"EnumProperty(...): maximum " STRINGIFY(
RNA_ENUM_BITFLAG_SIZE) " members for a ENUM_FLAG type property");
return NULL;
}
if (def && !PySet_Check(def)) {
PyErr_Format(PyExc_TypeError,
"EnumProperty(...): default option must be a 'set' "
"type when ENUM_FLAG is enabled, not a '%.200s'",
Py_TYPE(def)->tp_name);
return NULL;
}
}
else {
if (def) {
if (!py_long_as_int(def, &def_int_cmp)) {
def_string_cmp = _PyUnicode_AsString(def);
if (def_string_cmp == NULL) {
PyErr_Format(PyExc_TypeError,
"EnumProperty(...): default option must be a 'str' or 'int' "
"type when ENUM_FLAG is disabled, not a '%.200s'",
Py_TYPE(def)->tp_name);
return NULL;
}
}
}
}
/* blank value */
*defvalue = 0;
items = MEM_callocN(sizeof(EnumPropertyItem) * (seq_len + 1), "enum_items_from_py1");
for (i = 0; i < seq_len; i++) {
EnumPropertyItem tmp = {0, "", 0, "", ""};
const char *tmp_icon = NULL;
Py_ssize_t item_size;
Py_ssize_t id_str_size;
Py_ssize_t name_str_size;
Py_ssize_t desc_str_size;
item = seq_fast_items[i];
if ((PyTuple_CheckExact(item)) && (item_size = PyTuple_GET_SIZE(item)) &&
(item_size >= 3 && item_size <= 5) &&
(tmp.identifier = _PyUnicode_AsStringAndSize(PyTuple_GET_ITEM(item, 0), &id_str_size)) &&
(tmp.name = _PyUnicode_AsStringAndSize(PyTuple_GET_ITEM(item, 1), &name_str_size)) &&
(tmp.description = _PyUnicode_AsStringAndSize(PyTuple_GET_ITEM(item, 2),
&desc_str_size)) &&
/* TODO, number isn't ensured to be unique from the script author */
(item_size != 4 || py_long_as_int(PyTuple_GET_ITEM(item, 3), &tmp.value)) &&
(item_size != 5 || ((py_long_as_int(PyTuple_GET_ITEM(item, 3), &tmp.icon) ||
(tmp_icon = _PyUnicode_AsString(PyTuple_GET_ITEM(item, 3)))) &&
py_long_as_int(PyTuple_GET_ITEM(item, 4), &tmp.value)))) {
if (is_enum_flag) {
if (item_size < 4) {
tmp.value = 1 << i;
}
if (def && PySet_Contains(def, PyTuple_GET_ITEM(item, 0))) {
*defvalue |= tmp.value;
def_used++;
}
}
else {
if (item_size < 4) {
tmp.value = i;
}
if (def && def_used == 0) {
if ((def_string_cmp != NULL && STREQ(def_string_cmp, tmp.identifier)) ||
(def_string_cmp == NULL && def_int_cmp == tmp.value)) {
*defvalue = tmp.value;
def_used++; /* only ever 1 */
}
}
}
if (tmp_icon) {
tmp.icon = icon_id_from_name(tmp_icon);
}
items[i] = tmp;
/* calculate combine string length */
totbuf += id_str_size + name_str_size + desc_str_size + 3; /* 3 is for '\0's */
}
else if (item == Py_None) {
/* Only set since the rest is cleared. */
items[i].identifier = "";
}
else {
MEM_freeN(items);
PyErr_SetString(PyExc_TypeError,
"EnumProperty(...): expected a tuple containing "
"(identifier, name, description) and optionally an "
"icon name and unique number");
return NULL;
}
}
if (is_enum_flag) {
/* strict check that all set members were used */
if (def && def_used != PySet_GET_SIZE(def)) {
MEM_freeN(items);
PyErr_Format(PyExc_TypeError,
"EnumProperty(..., default={...}): set has %d unused member(s)",
PySet_GET_SIZE(def) - def_used);
return NULL;
}
}
else {
if (def && def_used == 0) {
MEM_freeN(items);
if (def_string_cmp) {
PyErr_Format(PyExc_TypeError,
"EnumProperty(..., default=\'%s\'): not found in enum members",
def_string_cmp);
}
else {
PyErr_Format(PyExc_TypeError,
"EnumProperty(..., default=%d): not found in enum members",
def_int_cmp);
}
return NULL;
}
}
/* disabled duplicating strings because the array can still be freed and
* the strings from it referenced, for now we can't support dynamically
* created strings from python. */
#if 0
/* this would all work perfectly _but_ the python strings may be freed
* immediately after use, so we need to duplicate them, ugh.
* annoying because it works most of the time without this. */
{
EnumPropertyItem *items_dup = MEM_mallocN((sizeof(EnumPropertyItem) * (seq_len + 1)) +
(sizeof(char) * totbuf),
"enum_items_from_py2");
EnumPropertyItem *items_ptr = items_dup;
char *buf = ((char *)items_dup) + (sizeof(EnumPropertyItem) * (seq_len + 1));
memcpy(items_dup, items, sizeof(EnumPropertyItem) * (seq_len + 1));
for (i = 0; i < seq_len; i++, items_ptr++) {
buf += strswapbufcpy(buf, &items_ptr->identifier);
buf += strswapbufcpy(buf, &items_ptr->name);
buf += strswapbufcpy(buf, &items_ptr->description);
}
MEM_freeN(items);
items = items_dup;
}
/* end string duplication */
#endif
return items;
}
static const EnumPropertyItem *bpy_prop_enum_itemf_cb(struct bContext *C,
PointerRNA *ptr,
PropertyRNA *prop,
bool *r_free)
{
PyGILState_STATE gilstate;
PyObject *py_func = RNA_property_enum_py_data_get(prop);
PyObject *self = NULL;
PyObject *args;
PyObject *items; /* returned from the function call */
const EnumPropertyItem *eitems = NULL;
int err = 0;
if (C) {
bpy_context_set(C, &gilstate);
}
else {
gilstate = PyGILState_Ensure();
}
args = PyTuple_New(2);
self = pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
/* now get the context */
if (C) {
PyTuple_SET_ITEM(args, 1, (PyObject *)bpy_context_module);
Py_INCREF(bpy_context_module);
}
else {
PyTuple_SET_ITEM(args, 1, Py_None);
Py_INCREF(Py_None);
}
items = PyObject_CallObject(py_func, args);
Py_DECREF(args);
if (items == NULL) {
err = -1;
}
else {
PyObject *items_fast;
int defvalue_dummy = 0;
if (!(items_fast = PySequence_Fast(items,
"EnumProperty(...): "
"return value from the callback was not a sequence"))) {
err = -1;
}
else {
eitems = enum_items_from_py(
items_fast, NULL, &defvalue_dummy, (RNA_property_flag(prop) & PROP_ENUM_FLAG) != 0);
Py_DECREF(items_fast);
if (!eitems) {
err = -1;
}
}
Py_DECREF(items);
}
if (err != -1) { /* worked */
*r_free = true;
}
else {
PyC_Err_PrintWithFunc(py_func);
eitems = DummyRNA_NULL_items;
}
if (C) {
bpy_context_clear(C, &gilstate);
}
else {
PyGILState_Release(gilstate);
}
return eitems;
}
static int bpy_prop_callback_check(PyObject *py_func, const char *keyword, int argcount)
{
if (py_func && py_func != Py_None) {
if (!PyFunction_Check(py_func)) {
PyErr_Format(PyExc_TypeError,
"%s keyword: expected a function type, not a %.200s",
keyword,
Py_TYPE(py_func)->tp_name);
return -1;
}
PyCodeObject *f_code = (PyCodeObject *)PyFunction_GET_CODE(py_func);
if (f_code->co_argcount != argcount) {
PyErr_Format(PyExc_TypeError,
"%s keyword: expected a function taking %d arguments, not %d",
keyword,
argcount,
f_code->co_argcount);
return -1;
}
}
return 0;
}
static PyObject **bpy_prop_py_data_get(struct PropertyRNA *prop)
{
PyObject **py_data = RNA_property_py_data_get(prop);
if (!py_data) {
py_data = MEM_callocN(sizeof(PyObject *) * BPY_DATA_CB_SLOT_SIZE, __func__);
RNA_def_py_data(prop, py_data);
}
return py_data;
}
static void bpy_prop_callback_assign_update(struct PropertyRNA *prop, PyObject *update_cb)
{
/* assume this is already checked for type and arg length */
if (update_cb && update_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
RNA_def_property_update_runtime(prop, (void *)bpy_prop_update_cb);
py_data[BPY_DATA_CB_SLOT_UPDATE] = update_cb;
RNA_def_property_flag(prop, PROP_CONTEXT_PROPERTY_UPDATE);
}
}
static void bpy_prop_callback_assign_pointer(struct PropertyRNA *prop, PyObject *poll_cb)
{
if (poll_cb && poll_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
RNA_def_property_poll_runtime(prop, (void *)bpy_prop_poll_cb);
py_data[BPY_DATA_CB_SLOT_POLL] = poll_cb;
}
}
static void bpy_prop_callback_assign_boolean(struct PropertyRNA *prop,
PyObject *get_cb,
PyObject *set_cb)
{
BooleanPropertyGetFunc rna_get_cb = NULL;
BooleanPropertySetFunc rna_set_cb = NULL;
if (get_cb && get_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_get_cb = bpy_prop_boolean_get_cb;
py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
}
if (set_cb && set_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_set_cb = bpy_prop_boolean_set_cb;
py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
}
RNA_def_property_boolean_funcs_runtime(prop, rna_get_cb, rna_set_cb);
}
static void bpy_prop_callback_assign_boolean_array(struct PropertyRNA *prop,
PyObject *get_cb,
PyObject *set_cb)
{
BooleanArrayPropertyGetFunc rna_get_cb = NULL;
BooleanArrayPropertySetFunc rna_set_cb = NULL;
if (get_cb && get_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_get_cb = bpy_prop_boolean_array_get_cb;
py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
}
if (set_cb && set_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_set_cb = bpy_prop_boolean_array_set_cb;
py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
}
RNA_def_property_boolean_array_funcs_runtime(prop, rna_get_cb, rna_set_cb);
}
static void bpy_prop_callback_assign_int(struct PropertyRNA *prop,
PyObject *get_cb,
PyObject *set_cb)
{
IntPropertyGetFunc rna_get_cb = NULL;
IntPropertySetFunc rna_set_cb = NULL;
if (get_cb && get_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_get_cb = bpy_prop_int_get_cb;
py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
}
if (set_cb && set_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_set_cb = bpy_prop_int_set_cb;
py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
}
RNA_def_property_int_funcs_runtime(prop, rna_get_cb, rna_set_cb, NULL);
}
static void bpy_prop_callback_assign_int_array(struct PropertyRNA *prop,
PyObject *get_cb,
PyObject *set_cb)
{
IntArrayPropertyGetFunc rna_get_cb = NULL;
IntArrayPropertySetFunc rna_set_cb = NULL;
if (get_cb && get_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_get_cb = bpy_prop_int_array_get_cb;
py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
}
if (set_cb && set_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_set_cb = bpy_prop_int_array_set_cb;
py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
}
RNA_def_property_int_array_funcs_runtime(prop, rna_get_cb, rna_set_cb, NULL);
}
static void bpy_prop_callback_assign_float(struct PropertyRNA *prop,
PyObject *get_cb,
PyObject *set_cb)
{
FloatPropertyGetFunc rna_get_cb = NULL;
FloatPropertySetFunc rna_set_cb = NULL;
if (get_cb && get_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_get_cb = bpy_prop_float_get_cb;
py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
}
if (set_cb && set_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_set_cb = bpy_prop_float_set_cb;
py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
}
RNA_def_property_float_funcs_runtime(prop, rna_get_cb, rna_set_cb, NULL);
}
static void bpy_prop_callback_assign_float_array(struct PropertyRNA *prop,
PyObject *get_cb,
PyObject *set_cb)
{
FloatArrayPropertyGetFunc rna_get_cb = NULL;
FloatArrayPropertySetFunc rna_set_cb = NULL;
if (get_cb && get_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_get_cb = bpy_prop_float_array_get_cb;
py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
}
if (set_cb && set_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_set_cb = bpy_prop_float_array_set_cb;
py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
}
RNA_def_property_float_array_funcs_runtime(prop, rna_get_cb, rna_set_cb, NULL);
}
static void bpy_prop_callback_assign_string(struct PropertyRNA *prop,
PyObject *get_cb,
PyObject *set_cb)
{
StringPropertyGetFunc rna_get_cb = NULL;
StringPropertyLengthFunc rna_length_cb = NULL;
StringPropertySetFunc rna_set_cb = NULL;
if (get_cb && get_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_get_cb = bpy_prop_string_get_cb;
rna_length_cb = bpy_prop_string_length_cb;
py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
}
if (set_cb && set_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_set_cb = bpy_prop_string_set_cb;
py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
}
RNA_def_property_string_funcs_runtime(prop, rna_get_cb, rna_length_cb, rna_set_cb);
}
static void bpy_prop_callback_assign_enum(struct PropertyRNA *prop,
PyObject *get_cb,
PyObject *set_cb,
PyObject *itemf_cb)
{
EnumPropertyGetFunc rna_get_cb = NULL;
EnumPropertyItemFunc rna_itemf_cb = NULL;
EnumPropertySetFunc rna_set_cb = NULL;
if (get_cb && get_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_get_cb = bpy_prop_enum_get_cb;
py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
}
if (set_cb && set_cb != Py_None) {
PyObject **py_data = bpy_prop_py_data_get(prop);
rna_set_cb = bpy_prop_enum_set_cb;
py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
}
if (itemf_cb && itemf_cb != Py_None) {
rna_itemf_cb = bpy_prop_enum_itemf_cb;
RNA_def_property_enum_py_data(prop, (void *)itemf_cb);
/* watch out!, if a user is tricky they can probably crash blender
* if they manage to free the callback, take care! */
/* Py_INCREF(itemf_cb); */
}
RNA_def_property_enum_funcs_runtime(prop, rna_get_cb, rna_set_cb, rna_itemf_cb);
}
/* this define runs at the start of each function and deals with
* returning a deferred property (to be registered later) */
#define BPY_PROPDEF_HEAD(_func) \
if (PyTuple_GET_SIZE(args) == 1) { \
PyObject *ret; \
self = PyTuple_GET_ITEM(args, 0); \
args = PyTuple_New(0); \
ret = BPy_##_func(self, args, kw); \
Py_DECREF(args); \
return ret; \
} \
if (PyTuple_GET_SIZE(args) > 1) { \
PyErr_SetString(PyExc_ValueError, "all args must be keywords"); \
return NULL; \
} \
srna = srna_from_self(self, #_func "(...):"); \
if (srna == NULL) { \
if (PyErr_Occurred()) { \
return NULL; \
} \
return bpy_prop_deferred_return(pymeth_##_func, kw); \
} \
(void)0
/* terse macros for error checks shared between all funcs cant use function
* calls because of static strings passed to pyrna_set_to_enum_bitfield */
#define BPY_PROPDEF_CHECK(_func, _property_flag_items, _property_flag_override_items) \
if (UNLIKELY(id_len >= MAX_IDPROP_NAME)) { \
PyErr_Format(PyExc_TypeError, \
#_func "(): '%.200s' too long, max length is %d", \
id, \
MAX_IDPROP_NAME - 1); \
return NULL; \
} \
if (UNLIKELY(RNA_def_property_free_identifier(srna, id) == -1)) { \
PyErr_Format(PyExc_TypeError, #_func "(): '%s' is defined as a non-dynamic type", id); \
return NULL; \
} \
if (UNLIKELY(pyopts && pyrna_set_to_enum_bitfield( \
_property_flag_items, pyopts, &opts, #_func "(options={ ...}):"))) { \
return NULL; \
} \
if (UNLIKELY(pyopts_override && pyrna_set_to_enum_bitfield(_property_flag_override_items, \
pyopts_override, \
&opts_override, \
#_func "(override={ ...}):"))) { \
return NULL; \
} \
{ \
const EnumPropertyItem *tag_defines = RNA_struct_property_tag_defines(srna); \
if (py_tags && !tag_defines) { \
PyErr_Format(PyExc_TypeError, \
#_func "(): property-tags not available for '%s'", \
RNA_struct_identifier(srna)); \
return NULL; \
} \
if (UNLIKELY(py_tags && pyrna_set_to_enum_bitfield( \
tag_defines, py_tags, &prop_tags, #_func "(tags={ ...}):"))) { \
return NULL; \
} \
} \
(void)0
#define BPY_PROPDEF_SUBTYPE_CHECK( \
_func, _property_flag_items, _property_flag_override_items, _subtype) \
BPY_PROPDEF_CHECK(_func, _property_flag_items, _property_flag_override_items); \
if (UNLIKELY(pysubtype && RNA_enum_value_from_id(_subtype, pysubtype, &subtype) == 0)) { \
const char *enum_str = BPy_enum_as_string(_subtype); \
PyErr_Format(PyExc_TypeError, \
#_func \
"(subtype='%s'): " \
"subtype not found in (%s)", \
pysubtype, \
enum_str); \
MEM_freeN((void *)enum_str); \
return NULL; \
} \
(void)0
#define BPY_PROPDEF_NAME_DOC \
" :arg name: Name used in the user interface.\n" \
" :type name: string\n"
#define BPY_PROPDEF_DESC_DOC \
" :arg description: Text used for the tooltip and api documentation.\n" \
" :type description: string\n"
#define BPY_PROPDEF_UNIT_DOC \
" :arg unit: Enumerator in ['NONE', 'LENGTH', 'AREA', 'VOLUME', 'ROTATION', 'TIME', " \
"'VELOCITY', 'ACCELERATION', 'MASS', 'CAMERA', 'POWER'].\n" \
" :type unit: string\n"
#define BPY_PROPDEF_NUM_MIN_DOC \
" :arg min: Hard minimum, trying to assign a value below will silently assign this minimum " \
"instead.\n"
#define BPY_PROPDEF_NUM_MAX_DOC \
" :arg max: Hard maximum, trying to assign a value above will silently assign this maximum " \
"instead.\n"
#define BPY_PROPDEF_NUM_SOFTMIN_DOC \
" :arg soft_min: Soft minimum (>= *min*), user won't be able to drag the widget below this " \
"value in the UI.\n"
#define BPY_PROPDEF_NUM_SOFTMAX_DOC \
" :arg soft_max: Soft maximum (<= *max*), user won't be able to drag the widget above this " \
"value in the UI.\n"
#define BPY_PROPDEF_VECSIZE_DOC \
" :arg size: Vector dimensions in [1, " STRINGIFY(PYRNA_STACK_ARRAY) "].\n" \
" :type size: int\n"
#define BPY_PROPDEF_INT_STEP_DOC \
" :arg step: Step of increment/decrement in UI, in [1, 100], defaults to 1 (WARNING: unused " \
"currently!).\n" \
" :type step: int\n"
#define BPY_PROPDEF_FLOAT_STEP_DOC \
" :arg step: Step of increment/decrement in UI, in [1, 100], defaults to 3 (WARNING: actual " \
"value is /100).\n" \
" :type step: int\n"
#define BPY_PROPDEF_FLOAT_PREC_DOC \
" :arg precision: Maximum number of decimal digits to display, in [0, 6].\n" \
" :type precision: int\n"
#define BPY_PROPDEF_UPDATE_DOC \
" :arg update: Function to be called when this value is modified,\n" \
" This function must take 2 values (self, context) and return None.\n" \
" *Warning* there are no safety checks to avoid infinite recursion.\n" \
" :type update: function\n"
#define BPY_PROPDEF_POLL_DOC \
" :arg poll: function to be called to determine whether an item is valid for this " \
"property.\n" \
" The function must take 2 values (self, object) and return Bool.\n" \
" :type poll: function\n"
#define BPY_PROPDEF_GET_DOC \
" :arg get: Function to be called when this value is 'read',\n" \
" This function must take 1 value (self) and return the value of the property.\n" \
" :type get: function\n"
#define BPY_PROPDEF_SET_DOC \
" :arg set: Function to be called when this value is 'written',\n" \
" This function must take 2 values (self, value) and return None.\n" \
" :type set: function\n"
#define BPY_PROPDEF_TYPE_DOC \
" :arg type: A subclass of :class:`bpy.types.PropertyGroup` or :class:`bpy.types.ID`.\n" \
" :type type: class\n"
#define BPY_PROPDEF_TAGS_DOC \
" :arg tags: Enumerator of tags that are defined by parent class.\n" \
" :type tags: set\n"
#if 0
static int bpy_struct_id_used(StructRNA *srna, char *identifier)
{
PointerRNA ptr;
RNA_pointer_create(NULL, srna, NULL, &ptr);
return (RNA_struct_find_property(&ptr, identifier) != NULL);
}
#endif
/* Function that sets RNA, NOTE - self is NULL when called from python,
* but being abused from C so we can pass the srna along.
* This isn't incorrect since its a python object - but be careful */
PyDoc_STRVAR(BPy_BoolProperty_doc,
".. function:: BoolProperty(name=\"\", "
"description=\"\", "
"default=False, "
"options={'ANIMATABLE'}, "
"override=set(), "
"tags=set(), "
"subtype='NONE', "
"update=None, "
"get=None, "
"set=None)\n"
"\n"
" Returns a new boolean property definition.\n"
"\n" BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC BPY_PROPDEF_OPTIONS_DOC
BPY_PROPDEF_OPTIONS_OVERRIDE_DOC BPY_PROPDEF_TAGS_DOC
BPY_PROPDEF_SUBTYPE_NUMBER_DOC BPY_PROPDEF_UPDATE_DOC BPY_PROPDEF_GET_DOC
BPY_PROPDEF_SET_DOC);
static PyObject *BPy_BoolProperty(PyObject *self, PyObject *args, PyObject *kw)
{
StructRNA *srna;
BPY_PROPDEF_HEAD(BoolProperty);
if (srna) {
const char *id = NULL, *name = NULL, *description = "";
Py_ssize_t id_len;
bool def = false;
PropertyRNA *prop;
PyObject *pyopts = NULL;
PyObject *pyopts_override = NULL;
int opts = 0;
int opts_override = 0;
int prop_tags = 0;
const char *pysubtype = NULL;
int subtype = PROP_NONE;
PyObject *update_cb = NULL;
PyObject *get_cb = NULL;
PyObject *set_cb = NULL;
PyObject *py_tags = NULL;
static const char *_keywords[] = {
"attr",
"name",
"description",
"default",
"options",
"override",
"tags",
"subtype",
"update",
"get",
"set",
NULL,
};
static _PyArg_Parser _parser = {"s#|ssO&O!O!O!sOOO:BoolProperty", _keywords, 0};
if (!_PyArg_ParseTupleAndKeywordsFast(args,
kw,
&_parser,
&id,
&id_len,
&name,
&description,
PyC_ParseBool,
&def,
&PySet_Type,
&pyopts,
&PySet_Type,
&pyopts_override,
&PySet_Type,
&py_tags,
&pysubtype,
&update_cb,
&get_cb,
&set_cb)) {
return NULL;
}
BPY_PROPDEF_SUBTYPE_CHECK(BoolProperty,
property_flag_items,
property_flag_override_items,
property_subtype_number_items);
if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
return NULL;
}
if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
return NULL;
}
if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
return NULL;
}
prop = RNA_def_property(srna, id, PROP_BOOLEAN, subtype);
RNA_def_property_boolean_default(prop, def);
RNA_def_property_ui_text(prop, name ? name : id, description);
if (py_tags) {
RNA_def_property_tags(prop, prop_tags);
}
if (pyopts) {
bpy_prop_assign_flag(prop, opts);
}
if (pyopts_override) {
bpy_prop_assign_flag_override(prop, opts_override);
}
bpy_prop_callback_assign_update(prop, update_cb);
bpy_prop_callback_assign_boolean(prop, get_cb, set_cb);
RNA_def_property_duplicate_pointers(srna, prop);
}
Py_RETURN_NONE;
}
PyDoc_STRVAR(
BPy_BoolVectorProperty_doc,
".. function:: BoolVectorProperty(name=\"\", "
"description=\"\", "
"default=(False, False, False), "
"options={'ANIMATABLE'}, "
"override=set(), "
"tags=set(), "
"subtype='NONE', "
"size=3, "
"update=None, "
"get=None, "
"set=None)\n"
"\n"
" Returns a new vector boolean property definition.\n"
"\n" BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC
" :arg default: sequence of booleans the length of *size*.\n"
" :type default: sequence\n" BPY_PROPDEF_OPTIONS_DOC BPY_PROPDEF_OPTIONS_OVERRIDE_DOC
BPY_PROPDEF_TAGS_DOC BPY_PROPDEF_SUBTYPE_ARRAY_DOC BPY_PROPDEF_VECSIZE_DOC
BPY_PROPDEF_UPDATE_DOC BPY_PROPDEF_GET_DOC BPY_PROPDEF_SET_DOC);
static PyObject *BPy_BoolVectorProperty(PyObject *self, PyObject *args, PyObject *kw)
{
StructRNA *srna;
BPY_PROPDEF_HEAD(BoolVectorProperty);
if (srna) {
const char *id = NULL, *name = NULL, *description = "";
Py_ssize_t id_len;
bool def[PYRNA_STACK_ARRAY] = {0};
int size = 3;
PropertyRNA *prop;
PyObject *pydef = NULL;
PyObject *pyopts = NULL;
PyObject *pyopts_override = NULL;
int opts = 0;
int opts_override = 0;
int prop_tags = 0;
const char *pysubtype = NULL;
int subtype = PROP_NONE;
PyObject *update_cb = NULL;
PyObject *get_cb = NULL;
PyObject *set_cb = NULL;
PyObject *py_tags = NULL;
static const char *_keywords[] = {
"attr",
"name",
"description",
"default",
"options",
"override",
"tags",
"subtype",
"size",
"update",
"get",
"set",
NULL,
};
static _PyArg_Parser _parser = {"s#|ssOO!O!O!siOOO:BoolVectorProperty", _keywords, 0};
if (!_PyArg_ParseTupleAndKeywordsFast(args,
kw,
&_parser,
&id,
&id_len,
&name,
&description,
&pydef,
&PySet_Type,
&pyopts,
&PySet_Type,
&pyopts_override,
&PySet_Type,
&py_tags,
&pysubtype,
&size,
&update_cb,
&get_cb,
&set_cb)) {
return NULL;
}
BPY_PROPDEF_SUBTYPE_CHECK(BoolVectorProperty,
property_flag_items,
property_flag_override_items,
property_subtype_array_items);
if (size < 1 || size > PYRNA_STACK_ARRAY) {
PyErr_Format(
PyExc_TypeError,
"BoolVectorProperty(size=%d): size must be between 0 and " STRINGIFY(PYRNA_STACK_ARRAY),
size);
return NULL;
}
if (pydef &&
PyC_AsArray(
def, pydef, size, &PyBool_Type, false, "BoolVectorProperty(default=sequence)") == -1) {
return NULL;
}
if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
return NULL;
}
if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
return NULL;
}
if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
return NULL;
}
#if 0
prop = RNA_def_boolean_array(
srna, id, size, pydef ? def : NULL, name ? name : id, description);
#endif
prop = RNA_def_property(srna, id, PROP_BOOLEAN, subtype);
RNA_def_property_array(prop, size);
if (pydef) {
RNA_def_property_boolean_array_default(prop, def);
}
RNA_def_property_ui_text(prop, name ? name : id, description);
if (py_tags) {
RNA_def_property_tags(prop, prop_tags);
}
if (pyopts) {
bpy_prop_assign_flag(prop, opts);
}
if (pyopts_override) {
bpy_prop_assign_flag_override(prop, opts_override);
}
bpy_prop_callback_assign_update(prop, update_cb);
bpy_prop_callback_assign_boolean_array(prop, get_cb, set_cb);
RNA_def_property_duplicate_pointers(srna, prop);
}
Py_RETURN_NONE;
}
PyDoc_STRVAR(
BPy_IntProperty_doc,
".. function:: IntProperty(name=\"\", "
"description=\"\", "
"default=0, "
"min=-2**31, max=2**31-1, "
"soft_min=-2**31, soft_max=2**31-1, "
"step=1, "
"options={'ANIMATABLE'}, "
"override=set(), "
"tags=set(), "
"subtype='NONE', "
"update=None, "
"get=None, "
"set=None)\n"
"\n"
" Returns a new int property definition.\n"
"\n" BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC BPY_PROPDEF_NUM_MIN_DOC
" :type min: int\n" BPY_PROPDEF_NUM_MAX_DOC " :type max: int\n" BPY_PROPDEF_NUM_SOFTMAX_DOC
" :type soft_min: int\n" BPY_PROPDEF_NUM_SOFTMIN_DOC
" :type soft_max: int\n" BPY_PROPDEF_INT_STEP_DOC BPY_PROPDEF_OPTIONS_DOC
BPY_PROPDEF_OPTIONS_OVERRIDE_DOC BPY_PROPDEF_TAGS_DOC BPY_PROPDEF_SUBTYPE_NUMBER_DOC
BPY_PROPDEF_UPDATE_DOC BPY_PROPDEF_GET_DOC BPY_PROPDEF_SET_DOC);
static PyObject *BPy_IntProperty(PyObject *self, PyObject *args, PyObject *kw)
{
StructRNA *srna;
BPY_PROPDEF_HEAD(IntProperty);
if (srna) {
const char *id = NULL, *name = NULL, *description = "";
Py_ssize_t id_len;
int min = INT_MIN, max = INT_MAX, soft_min = INT_MIN, soft_max = INT_MAX, step = 1, def = 0;
PropertyRNA *prop;
PyObject *pyopts = NULL;
int opts = 0;
PyObject *pyopts_override = NULL;
int opts_override = 0;
int prop_tags = 0;
const char *pysubtype = NULL;
int subtype = PROP_NONE;
PyObject *update_cb = NULL;
PyObject *get_cb = NULL;
PyObject *set_cb = NULL;
PyObject *py_tags = NULL;
static const char *_keywords[] = {
"attr",
"name",
"description",
"default",
"min",
"max",
"soft_min",
"soft_max",
"step",
"options",
"override",
"tags",
"subtype",
"update",
"get",
"set",
NULL,
};
static _PyArg_Parser _parser = {"s#|ssiiiiiiO!O!O!sOOO:IntProperty", _keywords, 0};
if (!_PyArg_ParseTupleAndKeywordsFast(args,
kw,
&_parser,
&id,
&id_len,
&name,
&description,
&def,
&min,
&max,
&soft_min,
&soft_max,
&step,
&PySet_Type,
&pyopts,
&PySet_Type,
&pyopts_override,
&PySet_Type,
&py_tags,
&pysubtype,
&update_cb,
&get_cb,
&set_cb)) {
return NULL;
}
BPY_PROPDEF_SUBTYPE_CHECK(IntProperty,
property_flag_items,
property_flag_override_items,
property_subtype_number_items);
if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
return NULL;
}
if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
return NULL;
}
if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
return NULL;
}
prop = RNA_def_property(srna, id, PROP_INT, subtype);
RNA_def_property_int_default(prop, def);
RNA_def_property_ui_text(prop, name ? name : id, description);
RNA_def_property_range(prop, min, max);
RNA_def_property_ui_range(prop, MAX2(soft_min, min), MIN2(soft_max, max), step, 3);
if (py_tags) {
RNA_def_property_tags(prop, prop_tags);
}
if (pyopts) {
bpy_prop_assign_flag(prop, opts);
}
if (pyopts_override) {
bpy_prop_assign_flag_override(prop, opts_override);
}
bpy_prop_callback_assign_update(prop, update_cb);
bpy_prop_callback_assign_int(prop, get_cb, set_cb);
RNA_def_property_duplicate_pointers(srna, prop);
}
Py_RETURN_NONE;
}
PyDoc_STRVAR(BPy_IntVectorProperty_doc,
".. function:: IntVectorProperty(name=\"\", "
"description=\"\", "
"default=(0, 0, 0), min=-2**31, max=2**31-1, "
"soft_min=-2**31, "
"soft_max=2**31-1, "
"step=1, "
"options={'ANIMATABLE'}, "
"override=set(), "
"tags=set(), "
"subtype='NONE', "
"size=3, "
"update=None, "
"get=None, "
"set=None)\n"
"\n"
" Returns a new vector int property definition.\n"
"\n" BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC
" :arg default: sequence of ints the length of *size*.\n"
" :type default: sequence\n" BPY_PROPDEF_NUM_MIN_DOC
" :type min: int\n" BPY_PROPDEF_NUM_MAX_DOC
" :type max: int\n" BPY_PROPDEF_NUM_SOFTMIN_DOC
" :type soft_min: int\n" BPY_PROPDEF_NUM_SOFTMAX_DOC
" :type soft_max: int\n" BPY_PROPDEF_INT_STEP_DOC BPY_PROPDEF_OPTIONS_DOC
BPY_PROPDEF_OPTIONS_OVERRIDE_DOC BPY_PROPDEF_TAGS_DOC
BPY_PROPDEF_SUBTYPE_ARRAY_DOC BPY_PROPDEF_VECSIZE_DOC BPY_PROPDEF_UPDATE_DOC
BPY_PROPDEF_GET_DOC BPY_PROPDEF_SET_DOC);
static PyObject *BPy_IntVectorProperty(PyObject *self, PyObject *args, PyObject *kw)
{
StructRNA *srna;
BPY_PROPDEF_HEAD(IntVectorProperty);
if (srna) {
const char *id = NULL, *name = NULL, *description = "";
Py_ssize_t id_len;
int min = INT_MIN, max = INT_MAX, soft_min = INT_MIN, soft_max = INT_MAX, step = 1;
int def[PYRNA_STACK_ARRAY] = {0};
int size = 3;
PropertyRNA *prop;
PyObject *pydef = NULL;
PyObject *pyopts = NULL;
int opts = 0;
PyObject *pyopts_override = NULL;
int opts_override = 0;
int prop_tags = 0;
const char *pysubtype = NULL;
int subtype = PROP_NONE;
PyObject *update_cb = NULL;
PyObject *get_cb = NULL;
PyObject *set_cb = NULL;
PyObject *py_tags = NULL;
static const char *_keywords[] = {
"attr",
"name",
"description",
"default",
"min",
"max",
"soft_min",
"soft_max",
"step",
"options",
"override",
"tags",
"subtype",
"size",
"update",
"get",
"set",
NULL,
};
static _PyArg_Parser _parser = {"s#|ssOiiiiiO!O!O!siOOO:IntVectorProperty", _keywords, 0};
if (!_PyArg_ParseTupleAndKeywordsFast(args,
kw,
&_parser,
&id,
&id_len,
&name,
&description,
&pydef,
&min,
&max,
&soft_min,
&soft_max,
&step,
&PySet_Type,
&pyopts,
&PySet_Type,
&pyopts_override,
&PySet_Type,
&py_tags,
&pysubtype,
&size,
&update_cb,
&get_cb,
&set_cb)) {
return NULL;
}
BPY_PROPDEF_SUBTYPE_CHECK(IntVectorProperty,
property_flag_items,
property_flag_override_items,
property_subtype_array_items);
if (size < 1 || size > PYRNA_STACK_ARRAY) {
PyErr_Format(
PyExc_TypeError,
"IntVectorProperty(size=%d): size must be between 0 and " STRINGIFY(PYRNA_STACK_ARRAY),
size);
return NULL;
}
if (pydef &&
PyC_AsArray(
def, pydef, size, &PyLong_Type, false, "IntVectorProperty(default=sequence)") == -1) {
return NULL;
}
if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
return NULL;
}
if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
return NULL;
}
if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
return NULL;
}
prop = RNA_def_property(srna, id, PROP_INT, subtype);
RNA_def_property_array(prop, size);
if (pydef) {
RNA_def_property_int_array_default(prop, def);
}
RNA_def_property_range(prop, min, max);
RNA_def_property_ui_text(prop, name ? name : id, description);
RNA_def_property_ui_range(prop, MAX2(soft_min, min), MIN2(soft_max, max), step, 3);
if (py_tags) {
RNA_def_property_tags(prop, prop_tags);
}
if (pyopts) {
bpy_prop_assign_flag(prop, opts);
}
if (pyopts_override) {
bpy_prop_assign_flag_override(prop, opts_override);
}
bpy_prop_callback_assign_update(prop, update_cb);
bpy_prop_callback_assign_int_array(prop, get_cb, set_cb);
RNA_def_property_duplicate_pointers(srna, prop);
}
Py_RETURN_NONE;
}
PyDoc_STRVAR(BPy_FloatProperty_doc,
".. function:: FloatProperty(name=\"\", "
"description=\"\", "
"default=0.0, "
"min=-3.402823e+38, max=3.402823e+38, "
"soft_min=-3.402823e+38, soft_max=3.402823e+38, "
"step=3, "
"precision=2, "
"options={'ANIMATABLE'}, "
"override=set(), "
"tags=set(), "
"subtype='NONE', "
"unit='NONE', "
"update=None, "
"get=None, "
"set=None)\n"
"\n"
" Returns a new float (single precision) property definition.\n"
"\n" BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC BPY_PROPDEF_NUM_MIN_DOC
" :type min: float\n" BPY_PROPDEF_NUM_MAX_DOC
" :type max: float\n" BPY_PROPDEF_NUM_SOFTMIN_DOC
" :type soft_min: float\n" BPY_PROPDEF_NUM_SOFTMAX_DOC
" :type soft_max: float\n" BPY_PROPDEF_FLOAT_STEP_DOC BPY_PROPDEF_FLOAT_PREC_DOC
BPY_PROPDEF_OPTIONS_DOC BPY_PROPDEF_OPTIONS_OVERRIDE_DOC BPY_PROPDEF_TAGS_DOC
BPY_PROPDEF_SUBTYPE_NUMBER_DOC BPY_PROPDEF_UNIT_DOC BPY_PROPDEF_UPDATE_DOC
BPY_PROPDEF_GET_DOC BPY_PROPDEF_SET_DOC);
static PyObject *BPy_FloatProperty(PyObject *self, PyObject *args, PyObject *kw)
{
StructRNA *srna;
BPY_PROPDEF_HEAD(FloatProperty);
if (srna) {
const char *id = NULL, *name = NULL, *description = "";
Py_ssize_t id_len;
float min = -FLT_MAX, max = FLT_MAX, soft_min = -FLT_MAX, soft_max = FLT_MAX, step = 3,
def = 0.0f;
int precision = 2;
PropertyRNA *prop;
PyObject *pyopts = NULL;
int opts = 0;
PyObject *pyopts_override = NULL;
int opts_override = 0;
int prop_tags = 0;
const char *pysubtype = NULL;
int subtype = PROP_NONE;
const char *pyunit = NULL;
int unit = PROP_UNIT_NONE;
PyObject *update_cb = NULL;
PyObject *get_cb = NULL;
PyObject *set_cb = NULL;
PyObject *py_tags = NULL;
static const char *_keywords[] = {
"attr", "name", "description", "default", "min", "max", "soft_min",
"soft_max", "step", "precision", "options", "override", "tags", "subtype",
"unit", "update", "get", "set", NULL,
};
static _PyArg_Parser _parser = {"s#|ssffffffiO!O!O!ssOOO:FloatProperty", _keywords, 0};
if (!_PyArg_ParseTupleAndKeywordsFast(args,
kw,
&_parser,
&id,
&id_len,
&name,
&description,
&def,
&min,
&max,
&soft_min,
&soft_max,
&step,
&precision,
&PySet_Type,
&pyopts,
&PySet_Type,
&pyopts_override,
&PySet_Type,
&py_tags,
&pysubtype,
&pyunit,
&update_cb,
&get_cb,
&set_cb)) {
return NULL;
}
BPY_PROPDEF_SUBTYPE_CHECK(FloatProperty,
property_flag_items,
property_flag_override_items,
property_subtype_number_items);
if (pyunit && RNA_enum_value_from_id(rna_enum_property_unit_items, pyunit, &unit) == 0) {
PyErr_Format(PyExc_TypeError, "FloatProperty(unit='%s'): invalid unit", pyunit);
return NULL;
}
if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
return NULL;
}
if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
return NULL;
}
if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
return NULL;
}
prop = RNA_def_property(srna, id, PROP_FLOAT, subtype | unit);
RNA_def_property_float_default(prop, def);
RNA_def_property_range(prop, min, max);
RNA_def_property_ui_text(prop, name ? name : id, description);
RNA_def_property_ui_range(prop, MAX2(soft_min, min), MIN2(soft_max, max), step, precision);
if (py_tags) {
RNA_def_property_tags(prop, prop_tags);
}
if (pyopts) {
bpy_prop_assign_flag(prop, opts);
}
if (pyopts_override) {
bpy_prop_assign_flag_override(prop, opts_override);
}
bpy_prop_callback_assign_update(prop, update_cb);
bpy_prop_callback_assign_float(prop, get_cb, set_cb);
RNA_def_property_duplicate_pointers(srna, prop);
}
Py_RETURN_NONE;
}
PyDoc_STRVAR(BPy_FloatVectorProperty_doc,
".. function:: FloatVectorProperty(name=\"\", "
"description=\"\", "
"default=(0.0, 0.0, 0.0), "
"min=sys.float_info.min, max=sys.float_info.max, "
"soft_min=sys.float_info.min, soft_max=sys.float_info.max, "
"step=3, "
"precision=2, "
"options={'ANIMATABLE'}, "
"override=set(), "
"tags=set(), "
"subtype='NONE', "
"unit='NONE', "
"size=3, "
"update=None, "
"get=None, "
"set=None)\n"
"\n"
" Returns a new vector float property definition.\n"
"\n" BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC
" :arg default: sequence of floats the length of *size*.\n"
" :type default: sequence\n" BPY_PROPDEF_NUM_MIN_DOC
" :type min: float\n" BPY_PROPDEF_NUM_MAX_DOC
" :type max: float\n" BPY_PROPDEF_NUM_SOFTMIN_DOC
" :type soft_min: float\n" BPY_PROPDEF_NUM_SOFTMAX_DOC
" :type soft_max: float\n" BPY_PROPDEF_OPTIONS_DOC BPY_PROPDEF_OPTIONS_OVERRIDE_DOC
BPY_PROPDEF_TAGS_DOC BPY_PROPDEF_FLOAT_STEP_DOC BPY_PROPDEF_FLOAT_PREC_DOC
BPY_PROPDEF_SUBTYPE_ARRAY_DOC BPY_PROPDEF_UNIT_DOC BPY_PROPDEF_VECSIZE_DOC
BPY_PROPDEF_UPDATE_DOC BPY_PROPDEF_GET_DOC BPY_PROPDEF_SET_DOC);
static PyObject *BPy_FloatVectorProperty(PyObject *self, PyObject *args, PyObject *kw)
{
StructRNA *srna;
BPY_PROPDEF_HEAD(FloatVectorProperty);
if (srna) {
const char *id = NULL, *name = NULL, *description = "";
Py_ssize_t id_len;
float min = -FLT_MAX, max = FLT_MAX, soft_min = -FLT_MAX, soft_max = FLT_MAX, step = 3;
float def[PYRNA_STACK_ARRAY] = {0.0f};
int precision = 2, size = 3;
PropertyRNA *prop;
PyObject *pydef = NULL;
PyObject *pyopts = NULL;
int opts = 0;
PyObject *pyopts_override = NULL;
int opts_override = 0;
int prop_tags = 0;
const char *pysubtype = NULL;
int subtype = PROP_NONE;
const char *pyunit = NULL;
int unit = PROP_UNIT_NONE;
PyObject *update_cb = NULL;
PyObject *get_cb = NULL;
PyObject *set_cb = NULL;
PyObject *py_tags = NULL;
static const char *_keywords[] = {
"attr", "name", "description", "default", "min", "max", "soft_min",
"soft_max", "step", "precision", "options", "override", "tags", "subtype",
"unit", "size", "update", "get", "set", NULL,
};
static _PyArg_Parser _parser = {"s#|ssOfffffiO!O!O!ssiOOO:FloatVectorProperty", _keywords, 0};
if (!_PyArg_ParseTupleAndKeywordsFast(args,
kw,
&_parser,
&id,
&id_len,
&name,
&description,
&pydef,
&min,
&max,
&soft_min,
&soft_max,
&step,
&precision,
&PySet_Type,
&pyopts,
&PySet_Type,
&pyopts_override,
&PySet_Type,
&py_tags,
&pysubtype,
&pyunit,
&size,
&update_cb,
&get_cb,
&set_cb)) {
return NULL;
}
BPY_PROPDEF_SUBTYPE_CHECK(FloatVectorProperty,
property_flag_items,
property_flag_override_items,
property_subtype_array_items);
if (pyunit && RNA_enum_value_from_id(rna_enum_property_unit_items, pyunit, &unit) == 0) {
PyErr_Format(PyExc_TypeError, "FloatVectorProperty(unit='%s'): invalid unit", pyunit);
return NULL;
}
if (size < 1 || size > PYRNA_STACK_ARRAY) {
PyErr_Format(
PyExc_TypeError,
"FloatVectorProperty(size=%d): size must be between 0 and " STRINGIFY(PYRNA_STACK_ARRAY),
size);
return NULL;
}
if (pydef &&
PyC_AsArray(
def, pydef, size, &PyFloat_Type, false, "FloatVectorProperty(default=sequence)") ==
-1) {
return NULL;
}
if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
return NULL;
}
if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
return NULL;
}
if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
return NULL;
}
prop = RNA_def_property(srna, id, PROP_FLOAT, subtype | unit);
RNA_def_property_array(prop, size);
if (pydef) {
RNA_def_property_float_array_default(prop, def);
}
RNA_def_property_range(prop, min, max);
RNA_def_property_ui_text(prop, name ? name : id, description);
RNA_def_property_ui_range(prop, MAX2(soft_min, min), MIN2(soft_max, max), step, precision);
if (py_tags) {
RNA_def_property_tags(prop, prop_tags);
}
if (pyopts) {
bpy_prop_assign_flag(prop, opts);
}
if (pyopts_override) {
bpy_prop_assign_flag_override(prop, opts_override);
}
bpy_prop_callback_assign_update(prop, update_cb);
bpy_prop_callback_assign_float_array(prop, get_cb, set_cb);
RNA_def_property_duplicate_pointers(srna, prop);
}
Py_RETURN_NONE;
}
PyDoc_STRVAR(BPy_StringProperty_doc,
".. function:: StringProperty(name=\"\", "
"description=\"\", "
"default=\"\", "
"maxlen=0, "
"options={'ANIMATABLE'}, "
"override=set(), "
"tags=set(), "
"subtype='NONE', "
"update=None, "
"get=None, "
"set=None)\n"
"\n"
" Returns a new string property definition.\n"
"\n" BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC
" :arg default: initializer string.\n"
" :type default: string\n"
" :arg maxlen: maximum length of the string.\n"
" :type maxlen: int\n" BPY_PROPDEF_OPTIONS_DOC BPY_PROPDEF_OPTIONS_OVERRIDE_DOC
BPY_PROPDEF_TAGS_DOC BPY_PROPDEF_SUBTYPE_STRING_DOC BPY_PROPDEF_UPDATE_DOC
BPY_PROPDEF_GET_DOC BPY_PROPDEF_SET_DOC);
static PyObject *BPy_StringProperty(PyObject *self, PyObject *args, PyObject *kw)
{
StructRNA *srna;
BPY_PROPDEF_HEAD(StringProperty);
if (srna) {
const char *id = NULL, *name = NULL, *description = "", *def = "";
Py_ssize_t id_len;
int maxlen = 0;
PropertyRNA *prop;
PyObject *pyopts = NULL;
int opts = 0;
PyObject *pyopts_override = NULL;
int opts_override = 0;
int prop_tags = 0;
const char *pysubtype = NULL;
int subtype = PROP_NONE;
PyObject *update_cb = NULL;
PyObject *get_cb = NULL;
PyObject *set_cb = NULL;
PyObject *py_tags = NULL;
static const char *_keywords[] = {
"attr",
"name",
"description",
"default",
"maxlen",
"options",
"override",
"tags",
"subtype",
"update",
"get",
"set",
NULL,
};
static _PyArg_Parser _parser = {"s#|sssiO!O!O!sOOO:StringProperty", _keywords, 0};
if (!_PyArg_ParseTupleAndKeywordsFast(args,
kw,
&_parser,
&id,
&id_len,
&name,
&description,
&def,
&maxlen,
&PySet_Type,
&pyopts,
&PySet_Type,
&pyopts_override,
&PySet_Type,
&py_tags,
&pysubtype,
&update_cb,
&get_cb,
&set_cb)) {
return NULL;
}
BPY_PROPDEF_SUBTYPE_CHECK(StringProperty,
property_flag_items,
property_flag_override_items,
property_subtype_string_items);
if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
return NULL;
}
if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
return NULL;
}
if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
return NULL;
}
prop = RNA_def_property(srna, id, PROP_STRING, subtype);
if (maxlen != 0) {
/* +1 since it includes null terminator. */
RNA_def_property_string_maxlength(prop, maxlen + 1);
}
if (def && def[0]) {
RNA_def_property_string_default(prop, def);
}
RNA_def_property_ui_text(prop, name ? name : id, description);
if (py_tags) {
RNA_def_property_tags(prop, prop_tags);
}
if (pyopts) {
bpy_prop_assign_flag(prop, opts);
}
if (pyopts_override) {
bpy_prop_assign_flag_override(prop, opts_override);
}
bpy_prop_callback_assign_update(prop, update_cb);
bpy_prop_callback_assign_string(prop, get_cb, set_cb);
RNA_def_property_duplicate_pointers(srna, prop);
}
Py_RETURN_NONE;
}
PyDoc_STRVAR(
BPy_EnumProperty_doc,
".. function:: EnumProperty(items, "
"name=\"\", "
"description=\"\", "
"default=None, "
"options={'ANIMATABLE'}, "
"override=set(), "
"tags=set(), "
"update=None, "
"get=None, "
"set=None)\n"
"\n"
" Returns a new enumerator property definition.\n"
"\n"
" :arg items: sequence of enum items formatted:\n"
" ``[(identifier, name, description, icon, number), ...]``.\n"
"\n"
" The first three elements of the tuples are mandatory.\n"
"\n"
" :identifier: The identifier is used for Python access.\n"
" :name: Name for the interface.\n"
" :description: Used for documentation and tooltips.\n"
" :icon: An icon string identifier or integer icon value\n"
" (e.g. returned by :class:`bpy.types.UILayout.icon`)\n"
" :number: Unique value used as the identifier for this item (stored in file data).\n"
" Use when the identifier may need to change. If the *ENUM_FLAG* option is used,\n"
" the values are bitmasks and should be powers of two.\n"
"\n"
" When an item only contains 4 items they define ``(identifier, name, description, "
"number)``.\n"
"\n"
" Separators may be added using None instead of a tuple."
"\n"
" For dynamic values a callback can be passed which returns a list in\n"
" the same format as the static list.\n"
" This function must take 2 arguments ``(self, context)``, **context may be None**.\n"
"\n"
" .. warning::\n"
"\n"
" There is a known bug with using a callback,\n"
" Python must keep a reference to the strings returned by the callback or Blender\n"
" will misbehave or even crash."
"\n"
" :type items: sequence of string tuples or a function\n" BPY_PROPDEF_NAME_DOC
BPY_PROPDEF_DESC_DOC
" :arg default: The default value for this enum, a string from the identifiers used in "
"*items*, or integer matching an item number.\n"
" If the *ENUM_FLAG* option is used this must be a set of such string identifiers "
"instead.\n"
" WARNING: Strings can not be specified for dynamic enums\n"
" (i.e. if a callback function is given as *items* parameter).\n"
" :type default: string, integer or set\n" BPY_PROPDEF_OPTIONS_ENUM_DOC
BPY_PROPDEF_OPTIONS_OVERRIDE_DOC BPY_PROPDEF_TAGS_DOC BPY_PROPDEF_UPDATE_DOC
BPY_PROPDEF_GET_DOC BPY_PROPDEF_SET_DOC);
static PyObject *BPy_EnumProperty(PyObject *self, PyObject *args, PyObject *kw)
{
StructRNA *srna;
BPY_PROPDEF_HEAD(EnumProperty);
if (srna) {
const char *id = NULL, *name = NULL, *description = "";
PyObject *def = NULL;
Py_ssize_t id_len;
int defvalue = 0;
PyObject *items, *items_fast;
const EnumPropertyItem *eitems;
PropertyRNA *prop;
PyObject *pyopts = NULL;
int opts = 0;
PyObject *pyopts_override = NULL;
int opts_override = 0;
int prop_tags = 0;
bool is_itemf = false;
PyObject *update_cb = NULL;
PyObject *get_cb = NULL;
PyObject *set_cb = NULL;
PyObject *py_tags = NULL;
static const char *_keywords[] = {
"attr",
"items",
"name",
"description",
"default",
"options",
"override",
"tags",
"update",
"get",
"set",
NULL,
};
static _PyArg_Parser _parser = {"s#O|ssOO!O!O!OOO:EnumProperty", _keywords, 0};
if (!_PyArg_ParseTupleAndKeywordsFast(args,
kw,
&_parser,
&id,
&id_len,
&items,
&name,
&description,
&def,
&PySet_Type,
&pyopts,
&PySet_Type,
&pyopts_override,
&PySet_Type,
&py_tags,
&update_cb,
&get_cb,
&set_cb)) {
return NULL;
}
BPY_PROPDEF_CHECK(EnumProperty, property_flag_enum_items, property_flag_override_items);
if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
return NULL;
}
if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
return NULL;
}
if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
return NULL;
}
if (def == Py_None) {
/* This allows to get same behavior when explicitly passing None as default value,
* and not defining a default value at all! */
def = NULL;
}
/* items can be a list or a callable */
if (PyFunction_Check(
items)) { /* don't use PyCallable_Check because we need the function code for errors */
PyCodeObject *f_code = (PyCodeObject *)PyFunction_GET_CODE(items);
if (f_code->co_argcount != 2) {
PyErr_Format(PyExc_ValueError,
"EnumProperty(...): expected 'items' function to take 2 arguments, not %d",
f_code->co_argcount);
return NULL;
}
if (def) {
/* Only support getting integer default values here. */
if (!py_long_as_int(def, &defvalue)) {
/* note, using type error here is odd but python does this for invalid arguments */
PyErr_SetString(
PyExc_TypeError,
"EnumProperty(...): 'default' can only be an integer when 'items' is a function");
return NULL;
}
}
is_itemf = true;
eitems = DummyRNA_NULL_items;
}
else {
if (!(items_fast = PySequence_Fast(
items,
"EnumProperty(...): "
"expected a sequence of tuples for the enum items or a function"))) {
return NULL;
}
eitems = enum_items_from_py(items_fast, def, &defvalue, (opts & PROP_ENUM_FLAG) != 0);
if (!eitems) {
Py_DECREF(items_fast);
return NULL;
}
}
if (opts & PROP_ENUM_FLAG) {
prop = RNA_def_enum_flag(srna, id, eitems, defvalue, name ? name : id, description);
}
else {
prop = RNA_def_enum(srna, id, eitems, defvalue, name ? name : id, description);
}
if (py_tags) {
RNA_def_property_tags(prop, prop_tags);
}
if (pyopts) {
bpy_prop_assign_flag(prop, opts);
}
if (pyopts_override) {
bpy_prop_assign_flag_override(prop, opts_override);
}
bpy_prop_callback_assign_update(prop, update_cb);
bpy_prop_callback_assign_enum(prop, get_cb, set_cb, (is_itemf ? items : NULL));
RNA_def_property_duplicate_pointers(srna, prop);
if (is_itemf == false) {
/* note: this must be postponed until after #RNA_def_property_duplicate_pointers
* otherwise if this is a generator it may free the strings before we copy them */
Py_DECREF(items_fast);
MEM_freeN((void *)eitems);
}
}
Py_RETURN_NONE;
}
StructRNA *pointer_type_from_py(PyObject *value, const char *error_prefix)
{
StructRNA *srna;
srna = srna_from_self(value, "");
if (!srna) {
if (PyErr_Occurred()) {
PyObject *msg = PyC_ExceptionBuffer();
const char *msg_char = _PyUnicode_AsString(msg);
PyErr_Format(
PyExc_TypeError, "%.200s expected an RNA type, failed with: %s", error_prefix, msg_char);
Py_DECREF(msg);
}
else {
PyErr_Format(PyExc_TypeError,
"%.200s expected an RNA type, failed with type '%s'",
error_prefix,
Py_TYPE(value)->tp_name);
}
return NULL;
}
return srna;
}
PyDoc_STRVAR(BPy_PointerProperty_doc,
".. function:: PointerProperty(type=None, "
"name=\"\", "
"description=\"\", "
"options={'ANIMATABLE'}, "
"override=set(), "
"tags=set(), "
"poll=None, "
"update=None)\n"
"\n"
" Returns a new pointer property definition.\n"
"\n" BPY_PROPDEF_TYPE_DOC BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC
BPY_PROPDEF_OPTIONS_DOC BPY_PROPDEF_OPTIONS_OVERRIDE_DOC BPY_PROPDEF_TAGS_DOC
BPY_PROPDEF_POLL_DOC BPY_PROPDEF_UPDATE_DOC);
PyObject *BPy_PointerProperty(PyObject *self, PyObject *args, PyObject *kw)
{
StructRNA *srna;
BPY_PROPDEF_HEAD(PointerProperty);
if (srna) {
const char *id = NULL, *name = NULL, *description = "";
Py_ssize_t id_len;
PropertyRNA *prop;
StructRNA *ptype;
PyObject *type = Py_None;
PyObject *pyopts = NULL;
PyObject *pyopts_override = NULL;
PyObject *py_tags = NULL;
int opts = 0;
int opts_override = 0;
int prop_tags = 0;
PyObject *update_cb = NULL, *poll_cb = NULL;
static const char *_keywords[] = {
"attr",
"type",
"name",
"description",
"options",
"override",
"tags",
"poll",
"update",
NULL,
};
static _PyArg_Parser _parser = {"s#O|ssO!O!O!OO:PointerProperty", _keywords, 0};
if (!_PyArg_ParseTupleAndKeywordsFast(args,
kw,
&_parser,
&id,
&id_len,
&type,
&name,
&description,
&PySet_Type,
&pyopts,
&PySet_Type,
&pyopts_override,
&PySet_Type,
&py_tags,
&poll_cb,
&update_cb)) {
return NULL;
}
BPY_PROPDEF_CHECK(PointerProperty, property_flag_items, property_flag_override_items);
ptype = pointer_type_from_py(type, "PointerProperty(...)");
if (!ptype) {
return NULL;
}
if (!RNA_struct_is_a(ptype, &RNA_PropertyGroup) && !RNA_struct_is_ID(ptype)) {
PyErr_Format(PyExc_TypeError,
"PointerProperty(...) expected an RNA type derived from %.200s or %.200s",
RNA_struct_ui_name(&RNA_ID),
RNA_struct_ui_name(&RNA_PropertyGroup));
return NULL;
}
if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
return NULL;
}
if (bpy_prop_callback_check(poll_cb, "poll", 2) == -1) {
return NULL;
}
prop = RNA_def_pointer_runtime(srna, id, ptype, name ? name : id, description);
if (py_tags) {
RNA_def_property_tags(prop, prop_tags);
}
if (pyopts) {
bpy_prop_assign_flag(prop, opts);
}
if (pyopts_override) {
bpy_prop_assign_flag_override(prop, opts_override);
}
if (RNA_struct_idprops_contains_datablock(ptype)) {
if (RNA_struct_is_a(srna, &RNA_PropertyGroup)) {
RNA_def_struct_flag(srna, STRUCT_CONTAINS_DATABLOCK_IDPROPERTIES);
}
}
bpy_prop_callback_assign_update(prop, update_cb);
bpy_prop_callback_assign_pointer(prop, poll_cb);
RNA_def_property_duplicate_pointers(srna, prop);
}
Py_RETURN_NONE;
}
PyDoc_STRVAR(BPy_CollectionProperty_doc,
".. function:: CollectionProperty(type=None, "
"name=\"\", "
"description=\"\", "
"options={'ANIMATABLE'}, "
"override=set(), "
"tags=set())\n"
"\n"
" Returns a new collection property definition.\n"
"\n" BPY_PROPDEF_TYPE_DOC BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC
BPY_PROPDEF_OPTIONS_DOC BPY_PROPDEF_OPTIONS_OVERRIDE_COLLECTION_DOC
BPY_PROPDEF_TAGS_DOC);
PyObject *BPy_CollectionProperty(PyObject *self, PyObject *args, PyObject *kw)
{
StructRNA *srna;
BPY_PROPDEF_HEAD(CollectionProperty);
if (srna) {
Py_ssize_t id_len;
const char *id = NULL, *name = NULL, *description = "";
PropertyRNA *prop;
StructRNA *ptype;
PyObject *type = Py_None;
PyObject *pyopts = NULL;
PyObject *pyopts_override = NULL;
PyObject *py_tags = NULL;
int opts = 0;
int opts_override = 0;
int prop_tags = 0;
static const char *_keywords[] = {
"attr",
"type",
"name",
"description",
"options",
"override",
"tags",
NULL,
};
static _PyArg_Parser _parser = {"s#O|ssO!O!O!:CollectionProperty", _keywords, 0};
if (!_PyArg_ParseTupleAndKeywordsFast(args,
kw,
&_parser,
&id,
&id_len,
&type,
&name,
&description,
&PySet_Type,
&pyopts,
&PySet_Type,
&pyopts_override,
&PySet_Type,
&py_tags)) {
return NULL;
}
BPY_PROPDEF_CHECK(
CollectionProperty, property_flag_items, property_flag_override_collection_items);
ptype = pointer_type_from_py(type, "CollectionProperty(...):");
if (!ptype) {
return NULL;
}
if (!RNA_struct_is_a(ptype, &RNA_PropertyGroup)) {
PyErr_Format(PyExc_TypeError,
"CollectionProperty(...) expected an RNA type derived from %.200s",
RNA_struct_ui_name(&RNA_PropertyGroup));
return NULL;
}
prop = RNA_def_collection_runtime(srna, id, ptype, name ? name : id, description);
if (py_tags) {
RNA_def_property_tags(prop, prop_tags);
}
if (pyopts) {
bpy_prop_assign_flag(prop, opts);
}
if (pyopts_override) {
bpy_prop_assign_flag_override(prop, opts_override);
}
if (RNA_struct_idprops_contains_datablock(ptype)) {
if (RNA_struct_is_a(srna, &RNA_PropertyGroup)) {
RNA_def_struct_flag(srna, STRUCT_CONTAINS_DATABLOCK_IDPROPERTIES);
}
}
RNA_def_property_duplicate_pointers(srna, prop);
}
Py_RETURN_NONE;
}
PyDoc_STRVAR(BPy_RemoveProperty_doc,
".. function:: RemoveProperty(cls, attr)\n"
"\n"
" Removes a dynamically defined property.\n"
"\n"
" :arg cls: The class containing the property (must be a positional argument).\n"
" :type cls: type\n"
" :arg attr: Property name (must be passed as a keyword).\n"
" :type attr: string\n"
"\n"
".. note:: Typically this function doesn't need to be accessed directly.\n"
" Instead use ``del cls.attr``\n");
static PyObject *BPy_RemoveProperty(PyObject *self, PyObject *args, PyObject *kw)
{
StructRNA *srna;
if (PyTuple_GET_SIZE(args) == 1) {
PyObject *ret;
self = PyTuple_GET_ITEM(args, 0);
args = PyTuple_New(0);
ret = BPy_RemoveProperty(self, args, kw);
Py_DECREF(args);
return ret;
}
if (PyTuple_GET_SIZE(args) > 1) {
PyErr_SetString(PyExc_ValueError, "expected one positional arg, one keyword arg");
return NULL;
}
srna = srna_from_self(self, "RemoveProperty(...):");
if (srna == NULL && PyErr_Occurred()) {
return NULL; /* self's type was compatible but error getting the srna */
}
if (srna == NULL) {
PyErr_SetString(PyExc_TypeError, "RemoveProperty(): struct rna not available for this type");
return NULL;
}
const char *id = NULL;
static const char *_keywords[] = {
"attr",
NULL,
};
static _PyArg_Parser _parser = {"s:RemoveProperty", _keywords, 0};
if (!_PyArg_ParseTupleAndKeywordsFast(args, kw, &_parser, &id)) {
return NULL;
}
if (RNA_def_property_free_identifier(srna, id) != 1) {
PyErr_Format(PyExc_TypeError, "RemoveProperty(): '%s' not a defined dynamic property", id);
return NULL;
}
Py_RETURN_NONE;
}
static struct PyMethodDef props_methods[] = {
{"BoolProperty",
(PyCFunction)BPy_BoolProperty,
METH_VARARGS | METH_KEYWORDS,
BPy_BoolProperty_doc},
{"BoolVectorProperty",
(PyCFunction)BPy_BoolVectorProperty,
METH_VARARGS | METH_KEYWORDS,
BPy_BoolVectorProperty_doc},
{"IntProperty",
(PyCFunction)BPy_IntProperty,
METH_VARARGS | METH_KEYWORDS,
BPy_IntProperty_doc},
{"IntVectorProperty",
(PyCFunction)BPy_IntVectorProperty,
METH_VARARGS | METH_KEYWORDS,
BPy_IntVectorProperty_doc},
{"FloatProperty",
(PyCFunction)BPy_FloatProperty,
METH_VARARGS | METH_KEYWORDS,
BPy_FloatProperty_doc},
{"FloatVectorProperty",
(PyCFunction)BPy_FloatVectorProperty,
METH_VARARGS | METH_KEYWORDS,
BPy_FloatVectorProperty_doc},
{"StringProperty",
(PyCFunction)BPy_StringProperty,
METH_VARARGS | METH_KEYWORDS,
BPy_StringProperty_doc},
{"EnumProperty",
(PyCFunction)BPy_EnumProperty,
METH_VARARGS | METH_KEYWORDS,
BPy_EnumProperty_doc},
{"PointerProperty",
(PyCFunction)BPy_PointerProperty,
METH_VARARGS | METH_KEYWORDS,
BPy_PointerProperty_doc},
{"CollectionProperty",
(PyCFunction)BPy_CollectionProperty,
METH_VARARGS | METH_KEYWORDS,
BPy_CollectionProperty_doc},
{"RemoveProperty",
(PyCFunction)BPy_RemoveProperty,
METH_VARARGS | METH_KEYWORDS,
BPy_RemoveProperty_doc},
{NULL, NULL, 0, NULL},
};
static struct PyModuleDef props_module = {
PyModuleDef_HEAD_INIT,
"bpy.props",
"This module defines properties to extend Blender's internal data. The result of these "
"functions"
" is used to assign properties to classes registered with Blender and can't be used "
"directly.\n"
"\n"
".. note:: All parameters to these functions must be passed as keywords.\n",
-1, /* multiple "initialization" just copies the module dict. */
props_methods,
NULL,
NULL,
NULL,
NULL,
};
PyObject *BPY_rna_props(void)
{
PyObject *submodule;
PyObject *submodule_dict;
submodule = PyModule_Create(&props_module);
PyDict_SetItemString(PyImport_GetModuleDict(), props_module.m_name, submodule);
/* api needs the PyObjects internally */
submodule_dict = PyModule_GetDict(submodule);
#define ASSIGN_STATIC(_name) pymeth_##_name = PyDict_GetItemString(submodule_dict, #_name)
ASSIGN_STATIC(BoolProperty);
ASSIGN_STATIC(BoolVectorProperty);
ASSIGN_STATIC(IntProperty);
ASSIGN_STATIC(IntVectorProperty);
ASSIGN_STATIC(FloatProperty);
ASSIGN_STATIC(FloatVectorProperty);
ASSIGN_STATIC(StringProperty);
ASSIGN_STATIC(EnumProperty);
ASSIGN_STATIC(PointerProperty);
ASSIGN_STATIC(CollectionProperty);
ASSIGN_STATIC(RemoveProperty);
return submodule;
}
View Git Blame Copy Permalink