source/blender/python/intern/bpy_props.c

   1 /**
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  *
  20  * Contributor(s): Campbell Barton
  21  *
  22  * ***** END GPL LICENSE BLOCK *****
  23  */
  24
  25 #include "bpy_props.h"
  26 #include "bpy_rna.h"
  27 #include "bpy_util.h"
  28
  29 #include "RNA_access.h"
  30 #include "RNA_define.h" /* for defining our own rna */
  31 #include "RNA_enum_types.h"
  32
  33 #include "MEM_guardedalloc.h"
  34
  35 #include "float.h" /* FLT_MIN/MAX */
  36
  37 EnumPropertyItem property_flag_items[] = {
  38         {PROP_HIDDEN, "HIDDEN", 0, "Hidden", ""},
  39         {PROP_ANIMATABLE, "ANIMATABLE", 0, "Animateable", ""},
  40         {0, NULL, 0, NULL, NULL}};
  41
  42 /* subtypes */
  43 EnumPropertyItem property_subtype_string_items[] = {
  44         {PROP_FILEPATH, "FILE_PATH", 0, "File Path", ""},
  45         {PROP_DIRPATH, "DIR_PATH", 0, "Directory Path", ""},
  46         {PROP_FILENAME, "FILENAME", 0, "Filename", ""},
  47
  48         {PROP_NONE, "NONE", 0, "None", ""},
  49         {0, NULL, 0, NULL, NULL}};
  50
  51 EnumPropertyItem property_subtype_number_items[] = {
  52         {PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned", ""},
  53         {PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", ""},
  54         {PROP_FACTOR, "FACTOR", 0, "Factor", ""},
  55         {PROP_ANGLE, "ANGLE", 0, "Angle", ""},
  56         {PROP_TIME, "TIME", 0, "Time", ""},
  57         {PROP_DISTANCE, "DISTANCE", 0, "Distance", ""},
  58
  59         {PROP_NONE, "NONE", 0, "None", ""},
  60         {0, NULL, 0, NULL, NULL}};
  61
  62 EnumPropertyItem property_subtype_array_items[] = {
  63         {PROP_COLOR, "COLOR", 0, "Color", ""},
  64         {PROP_TRANSLATION, "TRANSLATION", 0, "Translation", ""},
  65         {PROP_DIRECTION, "DIRECTION", 0, "Direction", ""},
  66         {PROP_VELOCITY, "VELOCITY", 0, "Velocity", ""},
  67         {PROP_ACCELERATION, "ACCELERATION", 0, "Acceleration", ""},
  68         {PROP_MATRIX, "MATRIX", 0, "Matrix", ""},
  69         {PROP_EULER, "EULER", 0, "Euler", ""},
  70         {PROP_QUATERNION, "QUATERNION", 0, "Quaternion", ""},
  71         {PROP_AXISANGLE, "AXISANGLE", 0, "Axis Angle", ""},
  72         {PROP_XYZ, "XYZ", 0, "XYZ", ""},
  73         {PROP_COLOR_GAMMA, "COLOR_GAMMA", 0, "Color Gamma", ""},
  74
  75         {PROP_NONE, "NONE", 0, "None", ""},
  76         {0, NULL, 0, NULL, NULL}};
  77
  78 /* operators use this so it can store the args given but defer running
  79  * it until the operator runs where these values are used to setup the
  80  * default args for that operator instance */
  81 static PyObject *bpy_prop_deferred_return(void *func, PyObject *kw)
  82 {
  83         PyObject *ret = PyTuple_New(2);
  84         PyTuple_SET_ITEM(ret, 0, PyCapsule_New(func, NULL, NULL));
  85         PyTuple_SET_ITEM(ret, 1, kw);
  86         Py_INCREF(kw);
  87         return ret;
  88 }
  89
  90 /* Function that sets RNA, NOTE - self is NULL when called from python, but being abused from C so we can pass the srna allong
  91  * This isnt incorrect since its a python object - but be careful */
  92 static char BPy_BoolProperty_doc[] =
  93 ".. function:: BoolProperty(name=\"\", description=\"\", default=False, options={'ANIMATABLE'}, subtype='NONE')\n"
  94 "\n"
  95 "   Returns a new boolean property definition.\n"
  96 "\n"
  97 "   :arg options: Enumerator in ['HIDDEN', 'ANIMATABLE'].\n"
  98 "   :type options: set\n"
  99 "   :arg subtype: Enumerator in ['UNSIGNED', 'PERCENTAGE', 'FACTOR', 'ANGLE', 'TIME', 'DISTANCE', 'NONE'].\n"
 100 "   :type subtype: string";
 101
 102 PyObject *BPy_BoolProperty(PyObject *self, PyObject *args, PyObject *kw)
 103 {
 104         StructRNA *srna;
 105
 106         if (PyTuple_GET_SIZE(args) > 0) {
 107                 PyErr_SetString(PyExc_ValueError, "all args must be keywors"); // TODO - py3 can enforce this.
 108                 return NULL;
 109         }
 110
 111         srna= srna_from_self(self);
 112         if(srna==NULL && PyErr_Occurred()) {
 113                 return NULL; /* self's type was compatible but error getting the srna */
 114         }
 115         else if(srna) {
 116                 static char *kwlist[] = {"attr", "name", "description", "default", "options", "subtype", NULL};
 117                 char *id=NULL, *name="", *description="";
 118                 int def=0;
 119                 PropertyRNA *prop;
 120                 PyObject *pyopts= NULL;
 121                 int opts=0;
 122                 char *pysubtype= NULL;
 123                 int subtype= PROP_NONE;
 124
 125                 if (!PyArg_ParseTupleAndKeywords(args, kw, "s|ssiO!s:BoolProperty", kwlist, &id, &name, &description, &def, &PySet_Type, &pyopts, &pysubtype))
 126                         return NULL;
 127
 128                 if(pyopts && pyrna_set_to_enum_bitfield(property_flag_items, pyopts, &opts, "BoolProperty(options={...}):"))
 129                         return NULL;
 130
 131                 if(pysubtype && RNA_enum_value_from_id(property_subtype_number_items, pysubtype, &subtype)==0) {
 132                         PyErr_Format(PyExc_TypeError, "BoolProperty(subtype='%s'): invalid subtype.");
 133                         return NULL;
 134                 }
 135
 136                 // prop= RNA_def_boolean(srna, id, def, name, description);
 137                 prop= RNA_def_property(srna, id, PROP_BOOLEAN, subtype);
 138                 RNA_def_property_boolean_default(prop, def);
 139                 RNA_def_property_ui_text(prop, name, description);
 140
 141                 if(pyopts) {
 142                         if(opts & PROP_HIDDEN) RNA_def_property_flag(prop, PROP_HIDDEN);
 143                         if((opts & PROP_ANIMATABLE)==0) RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 144                 }
 145                 RNA_def_property_duplicate_pointers(prop);
 146                 Py_RETURN_NONE;
 147         }
 148         else { /* operators defer running this function */
 149                 return bpy_prop_deferred_return((void *)BPy_BoolProperty, kw);
 150         }
 151 }
 152
 153 static char BPy_BoolVectorProperty_doc[] =
 154 ".. function:: BoolVectorProperty(name=\"\", description=\"\", default=(False, False, False), options={'ANIMATABLE'}, subtype='NONE', size=3)\n"
 155 "\n"
 156 "   Returns a new vector boolean property definition.\n"
 157 "\n"
 158 "   :arg options: Enumerator in ['HIDDEN', 'ANIMATABLE'].\n"
 159 "   :type options: set\n"
 160 "   :arg subtype: Enumerator in ['COLOR', 'TRANSLATION', 'DIRECTION', 'VELOCITY', 'ACCELERATION', 'MATRIX', 'EULER', 'QUATERNION', 'AXISANGLE', 'XYZ', 'COLOR_GAMMA', 'NONE'].\n"
 161 "   :type subtype: string";
 162 PyObject *BPy_BoolVectorProperty(PyObject *self, PyObject *args, PyObject *kw)
 163 {
 164         StructRNA *srna;
 165
 166         if (PyTuple_GET_SIZE(args) > 0) {
 167                 PyErr_SetString(PyExc_ValueError, "all args must be keywors"); // TODO - py3 can enforce this.
 168                 return NULL;
 169         }
 170
 171         srna= srna_from_self(self);
 172         if(srna==NULL && PyErr_Occurred()) {
 173                 return NULL; /* self's type was compatible but error getting the srna */
 174         }
 175         else if(srna) {
 176                 static char *kwlist[] = {"attr", "name", "description", "default", "options", "subtype", "size", NULL};
 177                 char *id=NULL, *name="", *description="";
 178                 int def[PYRNA_STACK_ARRAY]={0};
 179                 int size=3;
 180                 PropertyRNA *prop;
 181                 PyObject *pydef= NULL;
 182                 PyObject *pyopts= NULL;
 183                 int opts=0;
 184                 char *pysubtype= NULL;
 185                 int subtype= PROP_NONE;
 186
 187                 if (!PyArg_ParseTupleAndKeywords(args, kw, "s|ssOO!si:BoolVectorProperty", kwlist, &id, &name, &description, &pydef, &PySet_Type, &pyopts, &pysubtype, &size))
 188                         return NULL;
 189
 190                 if(pyopts && pyrna_set_to_enum_bitfield(property_flag_items, pyopts, &opts, "BoolVectorProperty(options={...}):"))
 191                         return NULL;
 192
 193                 if(pysubtype && RNA_enum_value_from_id(property_subtype_array_items, pysubtype, &subtype)==0) {
 194                         PyErr_Format(PyExc_TypeError, "BoolVectorProperty(subtype='%s'): invalid subtype.");
 195                         return NULL;
 196                 }
 197
 198                 if(size < 1 || size > PYRNA_STACK_ARRAY) {
 199                         PyErr_Format(PyExc_TypeError, "BoolVectorProperty(size=%d): size must be between 0 and %d.", size, PYRNA_STACK_ARRAY);
 200                         return NULL;
 201                 }
 202
 203                 if(pydef && BPyAsPrimitiveArray(def, pydef, size, &PyBool_Type, "BoolVectorProperty(default=sequence)") < 0)
 204                         return NULL;
 205
 206                 // prop= RNA_def_boolean_array(srna, id, size, pydef ? def:NULL, name, description);
 207                 prop= RNA_def_property(srna, id, PROP_BOOLEAN, subtype);
 208                 RNA_def_property_array(prop, size);
 209                 if(pydef) RNA_def_property_boolean_array_default(prop, def);
 210                 RNA_def_property_ui_text(prop, name, description);
 211
 212                 if(pyopts) {
 213                         if(opts & PROP_HIDDEN) RNA_def_property_flag(prop, PROP_HIDDEN);
 214                         if((opts & PROP_ANIMATABLE)==0) RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 215                 }
 216                 RNA_def_property_duplicate_pointers(prop);
 217                 Py_RETURN_NONE;
 218         }
 219         else { /* operators defer running this function */
 220                 return bpy_prop_deferred_return((void *)BPy_BoolVectorProperty, kw);
 221         }
 222 }
 223
 224 static char BPy_IntProperty_doc[] =
 225 ".. function:: IntProperty(name=\"\", description=\"\", default=0, min=-sys.maxint, max=sys.maxint, soft_min=-sys.maxint, soft_max=sys.maxint, step=1, options={'ANIMATABLE'}, subtype='NONE')\n"
 226 "\n"
 227 "   Returns a new int property definition.\n"
 228 "\n"
 229 "   :arg options: Enumerator in ['HIDDEN', 'ANIMATABLE'].\n"
 230 "   :type options: set\n"
 231 "   :arg subtype: Enumerator in ['UNSIGNED', 'PERCENTAGE', 'FACTOR', 'ANGLE', 'TIME', 'DISTANCE', 'NONE'].\n"
 232 "   :type subtype: string";
 233 PyObject *BPy_IntProperty(PyObject *self, PyObject *args, PyObject *kw)
 234 {
 235         StructRNA *srna;
 236
 237         if (PyTuple_GET_SIZE(args) > 0) {
 238                 PyErr_SetString(PyExc_ValueError, "all args must be keywors"); // TODO - py3 can enforce this.
 239                 return NULL;
 240         }
 241
 242         srna= srna_from_self(self);
 243         if(srna==NULL && PyErr_Occurred()) {
 244                 return NULL; /* self's type was compatible but error getting the srna */
 245         }
 246         else if(srna) {
 247                 static char *kwlist[] = {"attr", "name", "description", "default", "min", "max", "soft_min", "soft_max", "step", "options", "subtype", NULL};
 248                 char *id=NULL, *name="", *description="";
 249                 int min=INT_MIN, max=INT_MAX, soft_min=INT_MIN, soft_max=INT_MAX, step=1, def=0;
 250                 PropertyRNA *prop;
 251                 PyObject *pyopts= NULL;
 252                 int opts=0;
 253                 char *pysubtype= NULL;
 254                 int subtype= PROP_NONE;
 255
 256                 if (!PyArg_ParseTupleAndKeywords(args, kw, "s|ssiiiiiiO!s:IntProperty", kwlist, &id, &name, &description, &def, &min, &max, &soft_min, &soft_max, &step, &PySet_Type, &pyopts, &pysubtype))
 257                         return NULL;
 258
 259                 if(pyopts && pyrna_set_to_enum_bitfield(property_flag_items, pyopts, &opts, "IntProperty(options={...}):"))
 260                         return NULL;
 261
 262                 if(pysubtype && RNA_enum_value_from_id(property_subtype_number_items, pysubtype, &subtype)==0) {
 263                         PyErr_Format(PyExc_TypeError, "IntProperty(subtype='%s'): invalid subtype.");
 264                         return NULL;
 265                 }
 266
 267                 prop= RNA_def_property(srna, id, PROP_INT, subtype);
 268                 RNA_def_property_int_default(prop, def);
 269                 RNA_def_property_range(prop, min, max);
 270                 RNA_def_property_ui_text(prop, name, description);
 271                 RNA_def_property_ui_range(prop, soft_min, soft_max, step, 3);
 272
 273                 if(pyopts) {
 274                         if(opts & PROP_HIDDEN) RNA_def_property_flag(prop, PROP_HIDDEN);
 275                         if((opts & PROP_ANIMATABLE)==0) RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 276                 }
 277                 RNA_def_property_duplicate_pointers(prop);
 278                 Py_RETURN_NONE;
 279         }
 280         else { /* operators defer running this function */
 281                 return bpy_prop_deferred_return((void *)BPy_IntProperty, kw);
 282         }
 283 }
 284
 285 static char BPy_IntVectorProperty_doc[] =
 286 ".. function:: IntVectorProperty(name=\"\", description=\"\", default=(0, 0, 0), min=-sys.maxint, max=sys.maxint, soft_min=-sys.maxint, soft_max=sys.maxint, options={'ANIMATABLE'}, subtype='NONE', size=3)\n"
 287 "\n"
 288 "   Returns a new vector int property definition.\n"
 289 "\n"
 290 "   :arg options: Enumerator in ['HIDDEN', 'ANIMATABLE'].\n"
 291 "   :type options: set\n"
 292 "   :arg subtype: Enumerator in ['COLOR', 'TRANSLATION', 'DIRECTION', 'VELOCITY', 'ACCELERATION', 'MATRIX', 'EULER', 'QUATERNION', 'AXISANGLE', 'XYZ', 'COLOR_GAMMA', 'NONE'].\n"
 293 "   :type subtype: string";
 294 PyObject *BPy_IntVectorProperty(PyObject *self, PyObject *args, PyObject *kw)
 295 {
 296         StructRNA *srna;
 297
 298         if (PyTuple_GET_SIZE(args) > 0) {
 299                 PyErr_SetString(PyExc_ValueError, "all args must be keywors"); // TODO - py3 can enforce this.
 300                 return NULL;
 301         }
 302
 303         srna= srna_from_self(self);
 304         if(srna==NULL && PyErr_Occurred()) {
 305                 return NULL; /* self's type was compatible but error getting the srna */
 306         }
 307         else if(srna) {
 308                 static char *kwlist[] = {"attr", "name", "description", "default", "min", "max", "soft_min", "soft_max", "step", "options", "subtype", "size", NULL};
 309                 char *id=NULL, *name="", *description="";
 310                 int min=INT_MIN, max=INT_MAX, soft_min=INT_MIN, soft_max=INT_MAX, step=1, def[PYRNA_STACK_ARRAY]={0};
 311                 int size=3;
 312                 PropertyRNA *prop;
 313                 PyObject *pydef= NULL;
 314                 PyObject *pyopts= NULL;
 315                 int opts=0;
 316                 char *pysubtype= NULL;
 317                 int subtype= PROP_NONE;
 318
 319                 if (!PyArg_ParseTupleAndKeywords(args, kw, "s|ssOiiiiO!si:IntVectorProperty", kwlist, &id, &name, &description, &pydef, &min, &max, &soft_min, &soft_max, &PySet_Type, &pyopts, &pysubtype, &size))
 320                         return NULL;
 321
 322                 if(pyopts && pyrna_set_to_enum_bitfield(property_flag_items, pyopts, &opts, "IntVectorProperty(options={...}):"))
 323                         return NULL;
 324
 325                 if(pysubtype && RNA_enum_value_from_id(property_subtype_array_items, pysubtype, &subtype)==0) {
 326                         PyErr_Format(PyExc_TypeError, "IntVectorProperty(subtype='%s'): invalid subtype.");
 327                         return NULL;
 328                 }
 329
 330                 if(size < 1 || size > PYRNA_STACK_ARRAY) {
 331                         PyErr_Format(PyExc_TypeError, "IntVectorProperty(size=%d): size must be between 0 and %d.", size, PYRNA_STACK_ARRAY);
 332                         return NULL;
 333                 }
 334
 335                 if(pydef && BPyAsPrimitiveArray(def, pydef, size, &PyLong_Type, "IntVectorProperty(default=sequence)") < 0)
 336                         return NULL;
 337
 338                 prop= RNA_def_property(srna, id, PROP_INT, subtype);
 339                 RNA_def_property_array(prop, size);
 340                 if(pydef) RNA_def_property_int_array_default(prop, def);
 341                 RNA_def_property_range(prop, min, max);
 342                 RNA_def_property_ui_text(prop, name, description);
 343                 RNA_def_property_ui_range(prop, soft_min, soft_max, step, 3);
 344
 345                 if(pyopts) {
 346                         if(opts & PROP_HIDDEN) RNA_def_property_flag(prop, PROP_HIDDEN);
 347                         if((opts & PROP_ANIMATABLE)==0) RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 348                 }
 349                 RNA_def_property_duplicate_pointers(prop);
 350                 Py_RETURN_NONE;
 351         }
 352         else { /* operators defer running this function */
 353                 return bpy_prop_deferred_return((void *)BPy_IntVectorProperty, kw);
 354         }
 355 }
 356
 357
 358 static char BPy_FloatProperty_doc[] =
 359 ".. function:: FloatProperty(name=\"\", description=\"\", default=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'}, subtype='NONE', unit='NONE')\n"
 360 "\n"
 361 "   Returns a new float property definition.\n"
 362 "\n"
 363 "   :arg options: Enumerator in ['HIDDEN', 'ANIMATABLE'].\n"
 364 "   :type options: set\n"
 365 "   :arg subtype: Enumerator in ['UNSIGNED', 'PERCENTAGE', 'FACTOR', 'ANGLE', 'TIME', 'DISTANCE', 'NONE'].\n"
 366 "   :type subtype: string\n"
 367 "   :arg unit: Enumerator in ['NONE', 'LENGTH', 'AREA', 'VOLUME', 'ROTATION', 'TIME', 'VELOCITY', 'ACCELERATION'].\n"
 368 "   :type unit: string\n";
 369 PyObject *BPy_FloatProperty(PyObject *self, PyObject *args, PyObject *kw)
 370 {
 371         StructRNA *srna;
 372
 373         if (PyTuple_GET_SIZE(args) > 0) {
 374                 PyErr_SetString(PyExc_ValueError, "all args must be keywors"); // TODO - py3 can enforce this.
 375                 return NULL;
 376         }
 377
 378         srna= srna_from_self(self);
 379         if(srna==NULL && PyErr_Occurred()) {
 380                 return NULL; /* self's type was compatible but error getting the srna */
 381         }
 382         else if(srna) {
 383                 static char *kwlist[] = {"attr", "name", "description", "default", "min", "max", "soft_min", "soft_max", "step", "precision", "options", "subtype", "unit", NULL};
 384                 char *id=NULL, *name="", *description="";
 385                 float min=-FLT_MAX, max=FLT_MAX, soft_min=-FLT_MAX, soft_max=FLT_MAX, step=3, def=0.0f;
 386                 int precision= 2;
 387                 PropertyRNA *prop;
 388                 PyObject *pyopts= NULL;
 389                 int opts=0;
 390                 char *pysubtype= NULL;
 391                 int subtype= PROP_NONE;
 392                 char *pyunit= NULL;
 393                 int unit= PROP_UNIT_NONE;
 394
 395                 if (!PyArg_ParseTupleAndKeywords(args, kw, "s|ssffffffiO!ss:FloatProperty", kwlist, &id, &name, &description, &def, &min, &max, &soft_min, &soft_max, &step, &precision, &PySet_Type, &pyopts, &pysubtype, &pyunit))
 396                         return NULL;
 397
 398                 if(pyopts && pyrna_set_to_enum_bitfield(property_flag_items, pyopts, &opts, "FloatProperty(options={...}):"))
 399                         return NULL;
 400
 401                 if(pysubtype && RNA_enum_value_from_id(property_subtype_number_items, pysubtype, &subtype)==0) {
 402                         PyErr_Format(PyExc_TypeError, "FloatProperty(subtype='%s'): invalid subtype.");
 403                         return NULL;
 404                 }
 405
 406                 if(pyunit && RNA_enum_value_from_id(property_unit_items, pyunit, &unit)==0) {
 407                         PyErr_Format(PyExc_TypeError, "FloatProperty(unit='%s'): invalid unit.");
 408                         return NULL;
 409                 }
 410
 411                 prop= RNA_def_property(srna, id, PROP_FLOAT, subtype | unit);
 412                 RNA_def_property_float_default(prop, def);
 413                 RNA_def_property_range(prop, min, max);
 414                 RNA_def_property_ui_text(prop, name, description);
 415                 RNA_def_property_ui_range(prop, soft_min, soft_max, step, precision);
 416
 417                 if(pyopts) {
 418                         if(opts & PROP_HIDDEN) RNA_def_property_flag(prop, PROP_HIDDEN);
 419                         if((opts & PROP_ANIMATABLE)==0) RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 420                 }
 421                 RNA_def_property_duplicate_pointers(prop);
 422                 Py_RETURN_NONE;
 423         }
 424         else { /* operators defer running this function */
 425                 return bpy_prop_deferred_return((void *)BPy_FloatProperty, kw);
 426         }
 427 }
 428
 429 static char BPy_FloatVectorProperty_doc[] =
 430 ".. 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'}, subtype='NONE', size=3)\n"
 431 "\n"
 432 "   Returns a new vector float property definition.\n"
 433 "\n"
 434 "   :arg options: Enumerator in ['HIDDEN', 'ANIMATABLE'].\n"
 435 "   :type options: set\n"
 436 "   :arg subtype: Enumerator in ['COLOR', 'TRANSLATION', 'DIRECTION', 'VELOCITY', 'ACCELERATION', 'MATRIX', 'EULER', 'QUATERNION', 'AXISANGLE', 'XYZ', 'COLOR_GAMMA', 'NONE'].\n"
 437 "   :type subtype: string";
 438 PyObject *BPy_FloatVectorProperty(PyObject *self, PyObject *args, PyObject *kw)
 439 {
 440         StructRNA *srna;
 441
 442         if (PyTuple_GET_SIZE(args) > 0) {
 443                 PyErr_SetString(PyExc_ValueError, "all args must be keywors"); // TODO - py3 can enforce this.
 444                 return NULL;
 445         }
 446
 447         srna= srna_from_self(self);
 448         if(srna==NULL && PyErr_Occurred()) {
 449                 return NULL; /* self's type was compatible but error getting the srna */
 450         }
 451         else if(srna) {
 452                 static char *kwlist[] = {"attr", "name", "description", "default", "min", "max", "soft_min", "soft_max", "step", "precision", "options", "subtype", "size", NULL};
 453                 char *id=NULL, *name="", *description="";
 454                 float min=-FLT_MAX, max=FLT_MAX, soft_min=-FLT_MAX, soft_max=FLT_MAX, step=3, def[PYRNA_STACK_ARRAY]={0.0f};
 455                 int precision= 2, size=3;
 456                 PropertyRNA *prop;
 457                 PyObject *pydef= NULL;
 458                 PyObject *pyopts= NULL;
 459                 int opts=0;
 460                 char *pysubtype= NULL;
 461                 int subtype= PROP_NONE;
 462
 463                 if (!PyArg_ParseTupleAndKeywords(args, kw, "s|ssOfffffiO!si:FloatVectorProperty", kwlist, &id, &name, &description, &pydef, &min, &max, &soft_min, &soft_max, &step, &precision, &PySet_Type, &pyopts, &pysubtype, &size))
 464                         return NULL;
 465
 466                 if(pyopts && pyrna_set_to_enum_bitfield(property_flag_items, pyopts, &opts, "FloatVectorProperty(options={...}):"))
 467                         return NULL;
 468
 469                 if(pysubtype && RNA_enum_value_from_id(property_subtype_array_items, pysubtype, &subtype)==0) {
 470                         PyErr_Format(PyExc_TypeError, "FloatVectorProperty(subtype='%s'): invalid subtype.");
 471                         return NULL;
 472                 }
 473
 474                 if(size < 1 || size > PYRNA_STACK_ARRAY) {
 475                         PyErr_Format(PyExc_TypeError, "FloatVectorProperty(size=%d): size must be between 0 and %d.", size, PYRNA_STACK_ARRAY);
 476                         return NULL;
 477                 }
 478
 479                 if(pydef && BPyAsPrimitiveArray(def, pydef, size, &PyFloat_Type, "FloatVectorProperty(default=sequence)") < 0)
 480                         return NULL;
 481
 482                 prop= RNA_def_property(srna, id, PROP_FLOAT, subtype);
 483                 RNA_def_property_array(prop, size);
 484                 if(pydef) RNA_def_property_float_array_default(prop, def);
 485                 RNA_def_property_range(prop, min, max);
 486                 RNA_def_property_ui_text(prop, name, description);
 487                 RNA_def_property_ui_range(prop, soft_min, soft_max, step, precision);
 488
 489                 if(pyopts) {
 490                         if(opts & PROP_HIDDEN) RNA_def_property_flag(prop, PROP_HIDDEN);
 491                         if((opts & PROP_ANIMATABLE)==0) RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 492                 }
 493                 RNA_def_property_duplicate_pointers(prop);
 494                 Py_RETURN_NONE;
 495         }
 496         else { /* operators defer running this function */
 497                 return bpy_prop_deferred_return((void *)BPy_FloatVectorProperty, kw);
 498         }
 499 }
 500
 501 static char BPy_StringProperty_doc[] =
 502 ".. function:: StringProperty(name=\"\", description=\"\", default=\"\", maxlen=0, options={'ANIMATABLE'}, subtype='NONE')\n"
 503 "\n"
 504 "   Returns a new string property definition.\n"
 505 "\n"
 506 "   :arg options: Enumerator in ['HIDDEN', 'ANIMATABLE'].\n"
 507 "   :type options: set\n"
 508 "   :arg subtype: Enumerator in ['FILE_PATH', 'DIR_PATH', 'FILENAME', 'NONE'].\n"
 509 "   :type subtype: string";
 510 PyObject *BPy_StringProperty(PyObject *self, PyObject *args, PyObject *kw)
 511 {
 512         StructRNA *srna;
 513
 514         if (PyTuple_GET_SIZE(args) > 0) {
 515                 PyErr_SetString(PyExc_ValueError, "all args must be keywors"); // TODO - py3 can enforce this.
 516                 return NULL;
 517         }
 518
 519         srna= srna_from_self(self);
 520         if(srna==NULL && PyErr_Occurred()) {
 521                 return NULL; /* self's type was compatible but error getting the srna */
 522         }
 523         else if(srna) {
 524                 static char *kwlist[] = {"attr", "name", "description", "default", "maxlen", "options", "subtype", NULL};
 525                 char *id=NULL, *name="", *description="", *def="";
 526                 int maxlen=0;
 527                 PropertyRNA *prop;
 528                 PyObject *pyopts= NULL;
 529                 int opts=0;
 530                 char *pysubtype= NULL;
 531                 int subtype= PROP_NONE;
 532
 533                 if (!PyArg_ParseTupleAndKeywords(args, kw, "s|sssiO!s:StringProperty", kwlist, &id, &name, &description, &def, &maxlen, &PySet_Type, &pyopts, &pysubtype))
 534                         return NULL;
 535
 536                 if(pyopts && pyrna_set_to_enum_bitfield(property_flag_items, pyopts, &opts, "StringProperty(options={...}):"))
 537                         return NULL;
 538
 539                 if(pysubtype && RNA_enum_value_from_id(property_subtype_string_items, pysubtype, &subtype)==0) {
 540                         PyErr_Format(PyExc_TypeError, "StringProperty(subtype='%s'): invalid subtype.");
 541                         return NULL;
 542                 }
 543
 544                 prop= RNA_def_property(srna, id, PROP_STRING, subtype);
 545                 if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
 546                 if(def) RNA_def_property_string_default(prop, def);
 547                 RNA_def_property_ui_text(prop, name, description);
 548
 549                 if(pyopts) {
 550                         if(opts & PROP_HIDDEN) RNA_def_property_flag(prop, PROP_HIDDEN);
 551                         if((opts & PROP_ANIMATABLE)==0) RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 552                 }
 553                 RNA_def_property_duplicate_pointers(prop);
 554                 Py_RETURN_NONE;
 555         }
 556         else { /* operators defer running this function */
 557                 return bpy_prop_deferred_return((void *)BPy_StringProperty, kw);
 558         }
 559 }
 560
 561 static EnumPropertyItem *enum_items_from_py(PyObject *value, const char *def, int *defvalue)
 562 {
 563         EnumPropertyItem *items= NULL;
 564         PyObject *item;
 565         int seq_len, i, totitem= 0;
 566
 567         if(!PySequence_Check(value)) {
 568                 PyErr_SetString(PyExc_TypeError, "expected a sequence of tuples for the enum items");
 569                 return NULL;
 570         }
 571
 572         seq_len = PySequence_Length(value);
 573         for(i=0; i<seq_len; i++) {
 574                 EnumPropertyItem tmp= {0, "", 0, "", ""};
 575
 576                 item= PySequence_GetItem(value, i);
 577                 if(item==NULL || PyTuple_Check(item)==0) {
 578                         PyErr_SetString(PyExc_TypeError, "expected a sequence of tuples for the enum items");
 579                         if(items) MEM_freeN(items);
 580                         Py_XDECREF(item);
 581                         return NULL;
 582                 }
 583
 584                 if(!PyArg_ParseTuple(item, "sss", &tmp.identifier, &tmp.name, &tmp.description)) {
 585                         PyErr_SetString(PyExc_TypeError, "expected an identifier, name and description in the tuple");
 586                         Py_DECREF(item);
 587                         return NULL;
 588                 }
 589
 590                 tmp.value= i;
 591                 RNA_enum_item_add(&items, &totitem, &tmp);
 592
 593                 if(def[0] && strcmp(def, tmp.identifier) == 0)
 594                         *defvalue= tmp.value;
 595
 596                 Py_DECREF(item);
 597         }
 598
 599         if(!def[0])
 600                 *defvalue= 0;
 601
 602         RNA_enum_item_end(&items, &totitem);
 603
 604         return items;
 605 }
 606
 607 static char BPy_EnumProperty_doc[] =
 608 ".. function:: EnumProperty(items, name=\"\", description=\"\", default=\"\", options={'ANIMATABLE'})\n"
 609 "\n"
 610 "   Returns a new enumerator property definition.\n"
 611 "\n"
 612 "   :arg options: Enumerator in ['HIDDEN', 'ANIMATABLE'].\n"
 613 "   :type options: set\n"
 614 "   :arg items: The items that make up this enumerator.\n"
 615 "   :type items: sequence of string triplets";
 616 PyObject *BPy_EnumProperty(PyObject *self, PyObject *args, PyObject *kw)
 617 {
 618         StructRNA *srna;
 619
 620         if (PyTuple_GET_SIZE(args) > 0) {
 621                 PyErr_SetString(PyExc_ValueError, "all args must be keywors"); // TODO - py3 can enforce this.
 622                 return NULL;
 623         }
 624
 625         srna= srna_from_self(self);
 626         if(srna==NULL && PyErr_Occurred()) {
 627                 return NULL; /* self's type was compatible but error getting the srna */
 628         }
 629         else if(srna) {
 630                 static char *kwlist[] = {"attr", "items", "name", "description", "default", "options", NULL};
 631                 char *id=NULL, *name="", *description="", *def="";
 632                 int defvalue=0;
 633                 PyObject *items= Py_None;
 634                 EnumPropertyItem *eitems;
 635                 PropertyRNA *prop;
 636                 PyObject *pyopts= NULL;
 637                 int opts=0;
 638
 639                 if (!PyArg_ParseTupleAndKeywords(args, kw, "sO|sssO!:EnumProperty", kwlist, &id, &items, &name, &description, &def, &PySet_Type, &pyopts))
 640                         return NULL;
 641
 642                 if(pyopts && pyrna_set_to_enum_bitfield(property_flag_items, pyopts, &opts, "EnumProperty(options={...}):"))
 643                         return NULL;
 644
 645                 eitems= enum_items_from_py(items, def, &defvalue);
 646                 if(!eitems)
 647                         return NULL;
 648
 649                 prop= RNA_def_enum(srna, id, eitems, defvalue, name, description);
 650                 if(pyopts) {
 651                         if(opts & PROP_HIDDEN) RNA_def_property_flag(prop, PROP_HIDDEN);
 652                         if((opts & PROP_ANIMATABLE)==0) RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 653                 }
 654                 RNA_def_property_duplicate_pointers(prop);
 655                 MEM_freeN(eitems);
 656
 657                 Py_RETURN_NONE;
 658         }
 659         else { /* operators defer running this function */
 660                 return bpy_prop_deferred_return((void *)BPy_EnumProperty, kw);
 661         }
 662 }
 663
 664 static StructRNA *pointer_type_from_py(PyObject *value)
 665 {
 666         StructRNA *srna;
 667
 668         srna= srna_from_self(value);
 669         if(!srna) {
 670                 PyErr_SetString(PyExc_SystemError, "expected an RNA type derived from IDPropertyGroup");
 671                 return NULL;
 672         }
 673
 674         if(!RNA_struct_is_a(srna, &RNA_IDPropertyGroup)) {
 675                 PyErr_SetString(PyExc_SystemError, "expected an RNA type derived from IDPropertyGroup");
 676                 return NULL;
 677         }
 678
 679         return srna;
 680 }
 681
 682 static char BPy_PointerProperty_doc[] =
 683 ".. function:: PointerProperty(items, type=\"\", description=\"\", default=\"\", options={'ANIMATABLE'})\n"
 684 "\n"
 685 "   Returns a new pointer property definition.\n"
 686 "\n"
 687 "   :arg options: Enumerator in ['HIDDEN', 'ANIMATABLE'].\n"
 688 "   :type options: set\n"
 689 "   :arg type: Dynamic type from :mod:`bpy.types`.\n"
 690 "   :type type: class";
 691 PyObject *BPy_PointerProperty(PyObject *self, PyObject *args, PyObject *kw)
 692 {
 693         StructRNA *srna;
 694
 695         if (PyTuple_GET_SIZE(args) > 0) {
 696                 PyErr_SetString(PyExc_ValueError, "all args must be keywors"); // TODO - py3 can enforce this.
 697                 return NULL;
 698         }
 699
 700         srna= srna_from_self(self);
 701         if(srna==NULL && PyErr_Occurred()) {
 702                 return NULL; /* self's type was compatible but error getting the srna */
 703         }
 704         else if(srna) {
 705                 static char *kwlist[] = {"attr", "type", "name", "description", "options", NULL};
 706                 char *id=NULL, *name="", *description="";
 707                 PropertyRNA *prop;
 708                 StructRNA *ptype;
 709                 PyObject *type= Py_None;
 710                 PyObject *pyopts= NULL;
 711                 int opts=0;
 712
 713                 if (!PyArg_ParseTupleAndKeywords(args, kw, "sO|ssO!:PointerProperty", kwlist, &id, &type, &name, &description, &PySet_Type, &pyopts))
 714                         return NULL;
 715
 716                 if(pyopts && pyrna_set_to_enum_bitfield(property_flag_items, pyopts, &opts, "PointerProperty(options={...}):"))
 717                         return NULL;
 718
 719                 ptype= pointer_type_from_py(type);
 720                 if(!ptype)
 721                         return NULL;
 722
 723                 prop= RNA_def_pointer_runtime(srna, id, ptype, name, description);
 724                 if(pyopts) {
 725                         if(opts & PROP_HIDDEN) RNA_def_property_flag(prop, PROP_HIDDEN);
 726                         if((opts & PROP_ANIMATABLE)==0) RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 727                 }
 728                 RNA_def_property_duplicate_pointers(prop);
 729                 Py_RETURN_NONE;
 730         }
 731         else { /* operators defer running this function */
 732                 return bpy_prop_deferred_return((void *)BPy_PointerProperty, kw);
 733         }
 734         return NULL;
 735 }
 736
 737 static char BPy_CollectionProperty_doc[] =
 738 ".. function:: CollectionProperty(items, type=\"\", description=\"\", default=\"\", options={'ANIMATABLE'})\n"
 739 "\n"
 740 "   Returns a new collection property definition.\n"
 741 "\n"
 742 "   :arg options: Enumerator in ['HIDDEN', 'ANIMATABLE'].\n"
 743 "   :type options: set\n"
 744 "   :arg type: Dynamic type from :mod:`bpy.types`.\n"
 745 "   :type type: class";
 746 PyObject *BPy_CollectionProperty(PyObject *self, PyObject *args, PyObject *kw)
 747 {
 748         StructRNA *srna;
 749
 750         if (PyTuple_GET_SIZE(args) > 0) {
 751                 PyErr_SetString(PyExc_ValueError, "all args must be keywors"); // TODO - py3 can enforce this.
 752                 return NULL;
 753         }
 754
 755         srna= srna_from_self(self);
 756         if(srna==NULL && PyErr_Occurred()) {
 757                 return NULL; /* self's type was compatible but error getting the srna */
 758         }
 759         else if(srna) {
 760                 static char *kwlist[] = {"attr", "type", "name", "description", "options", NULL};
 761                 char *id=NULL, *name="", *description="";
 762                 PropertyRNA *prop;
 763                 StructRNA *ptype;
 764                 PyObject *type= Py_None;
 765                 PyObject *pyopts= NULL;
 766                 int opts=0;
 767
 768                 if (!PyArg_ParseTupleAndKeywords(args, kw, "sO|ssO!:CollectionProperty", kwlist, &id, &type, &name, &description, &PySet_Type, &pyopts))
 769                         return NULL;
 770
 771                 if(pyopts && pyrna_set_to_enum_bitfield(property_flag_items, pyopts, &opts, "CollectionProperty(options={...}):"))
 772                         return NULL;
 773
 774                 ptype= pointer_type_from_py(type);
 775                 if(!ptype)
 776                         return NULL;
 777
 778                 prop= RNA_def_collection_runtime(srna, id, ptype, name, description);
 779                 if(pyopts) {
 780                         if(opts & PROP_HIDDEN) RNA_def_property_flag(prop, PROP_HIDDEN);
 781                         if((opts & PROP_ANIMATABLE)==0) RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 782                 }
 783                 RNA_def_property_duplicate_pointers(prop);
 784                 Py_RETURN_NONE;
 785         }
 786         else { /* operators defer running this function */
 787                 return bpy_prop_deferred_return((void *)BPy_CollectionProperty, kw);
 788         }
 789         return NULL;
 790 }
 791
 792 static struct PyMethodDef props_methods[] = {
 793         {"BoolProperty", (PyCFunction)BPy_BoolProperty, METH_VARARGS|METH_KEYWORDS, BPy_BoolProperty_doc},
 794         {"BoolVectorProperty", (PyCFunction)BPy_BoolVectorProperty, METH_VARARGS|METH_KEYWORDS, BPy_BoolVectorProperty_doc},
 795         {"IntProperty", (PyCFunction)BPy_IntProperty, METH_VARARGS|METH_KEYWORDS, BPy_IntProperty_doc},
 796         {"IntVectorProperty", (PyCFunction)BPy_IntVectorProperty, METH_VARARGS|METH_KEYWORDS, BPy_IntVectorProperty_doc},
 797         {"FloatProperty", (PyCFunction)BPy_FloatProperty, METH_VARARGS|METH_KEYWORDS, BPy_FloatProperty_doc},
 798         {"FloatVectorProperty", (PyCFunction)BPy_FloatVectorProperty, METH_VARARGS|METH_KEYWORDS, BPy_FloatVectorProperty_doc},
 799         {"StringProperty", (PyCFunction)BPy_StringProperty, METH_VARARGS|METH_KEYWORDS, BPy_StringProperty_doc},
 800         {"EnumProperty", (PyCFunction)BPy_EnumProperty, METH_VARARGS|METH_KEYWORDS, BPy_EnumProperty_doc},
 801         {"PointerProperty", (PyCFunction)BPy_PointerProperty, METH_VARARGS|METH_KEYWORDS, BPy_PointerProperty_doc},
 802         {"CollectionProperty", (PyCFunction)BPy_CollectionProperty, METH_VARARGS|METH_KEYWORDS, BPy_CollectionProperty_doc},
 803         {NULL, NULL, 0, NULL}
 804 };
 805
 806 static struct PyModuleDef props_module = {
 807         PyModuleDef_HEAD_INIT,
 808         "bpy.props",
 809         "This module defines properties to extend blenders internal data, the result of these functions"
 810         " is used to assign properties to classes registered with blender and can't be used directly.",
 811         -1,/* multiple "initialization" just copies the module dict. */
 812         props_methods,
 813         NULL, NULL, NULL, NULL
 814 };
 815
 816 PyObject *BPY_rna_props( void )
 817 {
 818         PyObject *submodule;
 819         submodule= PyModule_Create(&props_module);
 820         PyDict_SetItemString(PySys_GetObject("modules"), props_module.m_name, submodule);
 821
 822         /* INCREF since its its assumed that all these functions return the
 823          * module with a new ref like PyDict_New, since they are passed to
 824           * PyModule_AddObject which steals a ref */
 825         Py_INCREF(submodule);
 826
 827         return submodule;
 828 }