Cleanup: misc spelling fixes
[blender.git] / source / blender / python / intern / bpy_props.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup pythonintern
19  *
20  * This file defines 'bpy.props' module used so scripts can define their own
21  * rna properties for use with python operators or adding new properties to
22  * existing blender types.
23  */
24
25 #include <Python.h>
26
27 #include "RNA_types.h"
28
29 #include "BLI_utildefines.h"
30
31 #include "bpy_props.h"
32 #include "bpy_rna.h"
33 #include "bpy_capi_utils.h"
34
35 #include "BKE_idprop.h"
36
37 #include "RNA_access.h"
38 #include "RNA_define.h" /* for defining our own rna */
39 #include "RNA_enum_types.h"
40
41 #include "MEM_guardedalloc.h"
42
43 #include "../generic/py_capi_utils.h"
44
45 /* initial definition of callback slots we'll probably have more than 1 */
46 enum {
47   BPY_DATA_CB_SLOT_UPDATE = 0,
48   BPY_DATA_CB_SLOT_GET = 1,
49   BPY_DATA_CB_SLOT_SET = 2,
50   BPY_DATA_CB_SLOT_POLL = 3,
51   BPY_DATA_CB_SLOT_SIZE = 4,
52 };
53
54 static const EnumPropertyItem property_flag_items[] = {
55     {PROP_HIDDEN, "HIDDEN", 0, "Hidden", ""},
56     {PROP_SKIP_SAVE, "SKIP_SAVE", 0, "Skip Save", ""},
57     {PROP_ANIMATABLE, "ANIMATABLE", 0, "Animatable", ""},
58     {PROP_LIB_EXCEPTION, "LIBRARY_EDITABLE", 0, "Library Editable", ""},
59     {PROP_PROPORTIONAL, "PROPORTIONAL", 0, "Adjust values proportionally to eachother", ""},
60     {PROP_TEXTEDIT_UPDATE,
61      "TEXTEDIT_UPDATE",
62      0,
63      "Update on every keystroke in textedit 'mode'",
64      ""},
65     {0, NULL, 0, NULL, NULL},
66 };
67
68 #define BPY_PROPDEF_OPTIONS_DOC \
69   "   :arg options: Enumerator in ['HIDDEN', 'SKIP_SAVE', 'ANIMATABLE', 'LIBRARY_EDITABLE', " \
70   "'PROPORTIONAL'," \
71   "'TEXTEDIT_UPDATE'].\n" \
72   "   :type options: set\n"
73
74 static const EnumPropertyItem property_flag_enum_items[] = {
75     {PROP_HIDDEN, "HIDDEN", 0, "Hidden", ""},
76     {PROP_SKIP_SAVE, "SKIP_SAVE", 0, "Skip Save", ""},
77     {PROP_ANIMATABLE, "ANIMATABLE", 0, "Animatable", ""},
78     {PROP_LIB_EXCEPTION, "LIBRARY_EDITABLE", 0, "Library Editable", ""},
79     {PROP_ENUM_FLAG, "ENUM_FLAG", 0, "Enum Flag", ""},
80     {0, NULL, 0, NULL, NULL},
81 };
82
83 #define BPY_PROPDEF_OPTIONS_ENUM_DOC \
84   "   :arg options: Enumerator in ['HIDDEN', 'SKIP_SAVE', 'ANIMATABLE', 'ENUM_FLAG', " \
85   "'LIBRARY_EDITABLE'].\n" \
86   "   :type options: set\n"
87
88 /* subtypes */
89 /* XXX Keep in sync with rna_rna.c's rna_enum_property_subtype_items ???
90  *     Currently it is not...
91  */
92 static const EnumPropertyItem property_subtype_string_items[] = {
93     {PROP_FILEPATH, "FILE_PATH", 0, "File Path", ""},
94     {PROP_DIRPATH, "DIR_PATH", 0, "Directory Path", ""},
95     {PROP_FILENAME, "FILE_NAME", 0, "Filename", ""},
96     {PROP_BYTESTRING, "BYTE_STRING", 0, "Byte String", ""},
97     {PROP_PASSWORD, "PASSWORD", 0, "Password", "A string that is displayed hidden ('********')"},
98
99     {PROP_NONE, "NONE", 0, "None", ""},
100     {0, NULL, 0, NULL, NULL},
101 };
102
103 #define BPY_PROPDEF_SUBTYPE_STRING_DOC \
104   "   :arg subtype: Enumerator in ['FILE_PATH', 'DIR_PATH', 'FILE_NAME', 'BYTE_STRING', " \
105   "'PASSWORD', 'NONE'].\n" \
106   "   :type subtype: string\n"
107
108 static const EnumPropertyItem property_subtype_number_items[] = {
109     {PROP_PIXEL, "PIXEL", 0, "Pixel", ""},
110     {PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned", ""},
111     {PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", ""},
112     {PROP_FACTOR, "FACTOR", 0, "Factor", ""},
113     {PROP_ANGLE, "ANGLE", 0, "Angle", ""},
114     {PROP_TIME, "TIME", 0, "Time", ""},
115     {PROP_DISTANCE, "DISTANCE", 0, "Distance", ""},
116
117     {PROP_NONE, "NONE", 0, "None", ""},
118     {0, NULL, 0, NULL, NULL},
119 };
120
121 #define BPY_PROPDEF_SUBTYPE_NUMBER_DOC \
122   "   :arg subtype: Enumerator in ['PIXEL', 'UNSIGNED', 'PERCENTAGE', 'FACTOR', 'ANGLE', " \
123   "'TIME', 'DISTANCE', 'NONE'].\n" \
124   "   :type subtype: string\n"
125
126 static const EnumPropertyItem property_subtype_array_items[] = {
127     {PROP_COLOR, "COLOR", 0, "Color", ""},
128     {PROP_TRANSLATION, "TRANSLATION", 0, "Translation", ""},
129     {PROP_DIRECTION, "DIRECTION", 0, "Direction", ""},
130     {PROP_VELOCITY, "VELOCITY", 0, "Velocity", ""},
131     {PROP_ACCELERATION, "ACCELERATION", 0, "Acceleration", ""},
132     {PROP_MATRIX, "MATRIX", 0, "Matrix", ""},
133     {PROP_EULER, "EULER", 0, "Euler", ""},
134     {PROP_QUATERNION, "QUATERNION", 0, "Quaternion", ""},
135     {PROP_AXISANGLE, "AXISANGLE", 0, "Axis Angle", ""},
136     {PROP_XYZ, "XYZ", 0, "XYZ", ""},
137     {PROP_COLOR_GAMMA, "COLOR_GAMMA", 0, "Color Gamma", ""},
138     {PROP_LAYER, "LAYER", 0, "Layer", ""},
139     {PROP_LAYER_MEMBER, "LAYER_MEMBER", 0, "Layer Member", ""},
140     {PROP_POWER, "POWER", 0, "Power", ""},
141
142     {PROP_NONE, "NONE", 0, "None", ""},
143     {0, NULL, 0, NULL, NULL},
144 };
145
146 #define BPY_PROPDEF_SUBTYPE_ARRAY_DOC \
147   "   :arg subtype: Enumerator in ['COLOR', 'TRANSLATION', 'DIRECTION', " \
148   "'VELOCITY', 'ACCELERATION', 'MATRIX', 'EULER', 'QUATERNION', 'AXISANGLE', " \
149   "'XYZ', 'COLOR_GAMMA', 'LAYER', 'LAYER_MEMBER', 'POWER', 'NONE'].\n" \
150   "   :type subtype: string\n"
151
152 /* PyObject's */
153 static PyObject *pymeth_BoolProperty = NULL;
154 static PyObject *pymeth_BoolVectorProperty = NULL;
155 static PyObject *pymeth_IntProperty = NULL;
156 static PyObject *pymeth_IntVectorProperty = NULL;
157 static PyObject *pymeth_FloatProperty = NULL;
158 static PyObject *pymeth_FloatVectorProperty = NULL;
159 static PyObject *pymeth_StringProperty = NULL;
160 static PyObject *pymeth_EnumProperty = NULL;
161 static PyObject *pymeth_PointerProperty = NULL;
162 static PyObject *pymeth_CollectionProperty = NULL;
163 static PyObject *pymeth_RemoveProperty = NULL;
164
165 static PyObject *pyrna_struct_as_instance(PointerRNA *ptr)
166 {
167   PyObject *self = NULL;
168   /* first get self */
169   /* operators can store their own instance for later use */
170   if (ptr->data) {
171     void **instance = RNA_struct_instance(ptr);
172
173     if (instance) {
174       if (*instance) {
175         self = *instance;
176         Py_INCREF(self);
177       }
178     }
179   }
180
181   /* in most cases this will run */
182   if (self == NULL) {
183     self = pyrna_struct_CreatePyObject(ptr);
184   }
185
186   return self;
187 }
188
189 static void bpy_prop_assign_flag(PropertyRNA *prop, const int flag)
190 {
191   const int flag_mask = ((PROP_ANIMATABLE) & ~flag);
192
193   if (flag) {
194     RNA_def_property_flag(prop, flag);
195   }
196
197   if (flag_mask) {
198     RNA_def_property_clear_flag(prop, flag_mask);
199   }
200 }
201
202 /* operators and classes use this so it can store the args given but defer
203  * running it until the operator runs where these values are used to setup
204  * the default args for that operator instance */
205 static PyObject *bpy_prop_deferred_return(PyObject *func, PyObject *kw)
206 {
207   PyObject *ret = PyTuple_New(2);
208   PyTuple_SET_ITEM(ret, 0, func);
209   Py_INCREF(func);
210
211   if (kw == NULL) {
212     kw = PyDict_New();
213   }
214   else {
215     Py_INCREF(kw);
216   }
217
218   PyTuple_SET_ITEM(ret, 1, kw);
219
220   return ret;
221 }
222
223 /* callbacks */
224 static void bpy_prop_update_cb(struct bContext *C,
225                                struct PointerRNA *ptr,
226                                struct PropertyRNA *prop)
227 {
228   PyGILState_STATE gilstate;
229   PyObject **py_data = RNA_property_py_data_get(prop);
230   PyObject *py_func;
231   PyObject *args;
232   PyObject *self;
233   PyObject *ret;
234   const bool is_write_ok = pyrna_write_check();
235
236   BLI_assert(py_data != NULL);
237
238   if (!is_write_ok) {
239     pyrna_write_set(true);
240   }
241
242   bpy_context_set(C, &gilstate);
243
244   py_func = py_data[BPY_DATA_CB_SLOT_UPDATE];
245
246   args = PyTuple_New(2);
247   self = pyrna_struct_as_instance(ptr);
248   PyTuple_SET_ITEM(args, 0, self);
249
250   PyTuple_SET_ITEM(args, 1, (PyObject *)bpy_context_module);
251   Py_INCREF(bpy_context_module);
252
253   ret = PyObject_CallObject(py_func, args);
254
255   Py_DECREF(args);
256
257   if (ret == NULL) {
258     PyC_Err_PrintWithFunc(py_func);
259   }
260   else {
261     if (ret != Py_None) {
262       PyErr_SetString(PyExc_ValueError, "the return value must be None");
263       PyC_Err_PrintWithFunc(py_func);
264     }
265
266     Py_DECREF(ret);
267   }
268
269   bpy_context_clear(C, &gilstate);
270
271   if (!is_write_ok) {
272     pyrna_write_set(false);
273   }
274 }
275
276 static bool bpy_prop_boolean_get_cb(struct PointerRNA *ptr, struct PropertyRNA *prop)
277 {
278   PyObject **py_data = RNA_property_py_data_get(prop);
279   PyObject *py_func;
280   PyObject *args;
281   PyObject *self;
282   PyObject *ret;
283   PyGILState_STATE gilstate;
284   bool use_gil;
285   const bool is_write_ok = pyrna_write_check();
286   bool value;
287
288   BLI_assert(py_data != NULL);
289
290   if (!is_write_ok) {
291     pyrna_write_set(true);
292   }
293
294   use_gil = true; /* !PyC_IsInterpreterActive(); */
295
296   if (use_gil) {
297     gilstate = PyGILState_Ensure();
298   }
299
300   py_func = py_data[BPY_DATA_CB_SLOT_GET];
301
302   args = PyTuple_New(1);
303   self = pyrna_struct_as_instance(ptr);
304   PyTuple_SET_ITEM(args, 0, self);
305
306   ret = PyObject_CallObject(py_func, args);
307
308   Py_DECREF(args);
309
310   if (ret == NULL) {
311     PyC_Err_PrintWithFunc(py_func);
312     value = false;
313   }
314   else {
315     int value_i = PyC_Long_AsBool(ret);
316
317     if (value_i == -1 && PyErr_Occurred()) {
318       PyC_Err_PrintWithFunc(py_func);
319       value = false;
320     }
321     else {
322       value = (bool)value_i;
323     }
324
325     Py_DECREF(ret);
326   }
327
328   if (use_gil) {
329     PyGILState_Release(gilstate);
330   }
331
332   if (!is_write_ok) {
333     pyrna_write_set(false);
334   }
335
336   return value;
337 }
338
339 static void bpy_prop_boolean_set_cb(struct PointerRNA *ptr, struct PropertyRNA *prop, bool value)
340 {
341   PyObject **py_data = RNA_property_py_data_get(prop);
342   PyObject *py_func;
343   PyObject *args;
344   PyObject *self;
345   PyObject *ret;
346   PyGILState_STATE gilstate;
347   bool use_gil;
348   const bool is_write_ok = pyrna_write_check();
349
350   BLI_assert(py_data != NULL);
351
352   if (!is_write_ok) {
353     pyrna_write_set(true);
354   }
355
356   use_gil = true; /* !PyC_IsInterpreterActive(); */
357
358   if (use_gil) {
359     gilstate = PyGILState_Ensure();
360   }
361
362   py_func = py_data[BPY_DATA_CB_SLOT_SET];
363
364   args = PyTuple_New(2);
365   self = pyrna_struct_as_instance(ptr);
366   PyTuple_SET_ITEM(args, 0, self);
367
368   PyTuple_SET_ITEM(args, 1, PyBool_FromLong(value));
369
370   ret = PyObject_CallObject(py_func, args);
371
372   Py_DECREF(args);
373
374   if (ret == NULL) {
375     PyC_Err_PrintWithFunc(py_func);
376   }
377   else {
378     if (ret != Py_None) {
379       PyErr_SetString(PyExc_ValueError, "the return value must be None");
380       PyC_Err_PrintWithFunc(py_func);
381     }
382
383     Py_DECREF(ret);
384   }
385
386   if (use_gil) {
387     PyGILState_Release(gilstate);
388   }
389
390   if (!is_write_ok) {
391     pyrna_write_set(false);
392   }
393 }
394
395 static bool bpy_prop_poll_cb(struct PointerRNA *self,
396                              PointerRNA candidate,
397                              struct PropertyRNA *prop)
398 {
399   PyObject *py_self;
400   PyObject *py_candidate;
401   PyObject *py_func;
402   PyObject **py_data = RNA_property_py_data_get(prop);
403   PyObject *args;
404   PyObject *ret;
405   bool result;
406   const int is_write_ok = pyrna_write_check();
407   PyGILState_STATE gilstate = PyGILState_Ensure();
408
409   BLI_assert(self != NULL);
410
411   py_self = pyrna_struct_as_instance(self);
412   py_candidate = pyrna_struct_as_instance(&candidate);
413   py_func = py_data[BPY_DATA_CB_SLOT_POLL];
414
415   if (!is_write_ok) {
416     pyrna_write_set(true);
417   }
418
419   args = PyTuple_New(2);
420   PyTuple_SET_ITEM(args, 0, py_self);
421   PyTuple_SET_ITEM(args, 1, py_candidate);
422
423   ret = PyObject_CallObject(py_func, args);
424
425   Py_DECREF(args);
426
427   if (ret == NULL) {
428     PyC_Err_PrintWithFunc(py_func);
429     result = false;
430   }
431   else {
432     result = PyObject_IsTrue(ret);
433     Py_DECREF(ret);
434   }
435
436   PyGILState_Release(gilstate);
437   if (!is_write_ok) {
438     pyrna_write_set(false);
439   }
440
441   return result;
442 }
443
444 static void bpy_prop_boolean_array_get_cb(struct PointerRNA *ptr,
445                                           struct PropertyRNA *prop,
446                                           bool *values)
447 {
448   PyObject **py_data = RNA_property_py_data_get(prop);
449   PyObject *py_func;
450   PyObject *args;
451   PyObject *self;
452   PyObject *ret;
453   PyGILState_STATE gilstate;
454   bool use_gil;
455   const bool is_write_ok = pyrna_write_check();
456   int i, len = RNA_property_array_length(ptr, prop);
457
458   BLI_assert(py_data != NULL);
459
460   if (!is_write_ok) {
461     pyrna_write_set(true);
462   }
463
464   use_gil = true; /* !PyC_IsInterpreterActive(); */
465
466   if (use_gil) {
467     gilstate = PyGILState_Ensure();
468   }
469
470   py_func = py_data[BPY_DATA_CB_SLOT_GET];
471
472   args = PyTuple_New(1);
473   self = pyrna_struct_as_instance(ptr);
474   PyTuple_SET_ITEM(args, 0, self);
475
476   ret = PyObject_CallObject(py_func, args);
477
478   Py_DECREF(args);
479
480   if (ret == NULL) {
481     PyC_Err_PrintWithFunc(py_func);
482
483     for (i = 0; i < len; ++i) {
484       values[i] = false;
485     }
486   }
487   else {
488     if (PyC_AsArray(values, ret, len, &PyBool_Type, false, "BoolVectorProperty get") == -1) {
489       PyC_Err_PrintWithFunc(py_func);
490
491       for (i = 0; i < len; ++i) {
492         values[i] = false;
493       }
494
495       /* PyC_AsArray decrements refcount internally on error */
496     }
497     else {
498       Py_DECREF(ret);
499     }
500   }
501
502   if (use_gil) {
503     PyGILState_Release(gilstate);
504   }
505
506   if (!is_write_ok) {
507     pyrna_write_set(false);
508   }
509 }
510
511 static void bpy_prop_boolean_array_set_cb(struct PointerRNA *ptr,
512                                           struct PropertyRNA *prop,
513                                           const bool *values)
514 {
515   PyObject **py_data = RNA_property_py_data_get(prop);
516   PyObject *py_func;
517   PyObject *args;
518   PyObject *self;
519   PyObject *ret;
520   PyObject *py_values;
521   PyGILState_STATE gilstate;
522   bool use_gil;
523   const bool is_write_ok = pyrna_write_check();
524   int len = RNA_property_array_length(ptr, prop);
525
526   BLI_assert(py_data != NULL);
527
528   if (!is_write_ok) {
529     pyrna_write_set(true);
530   }
531
532   use_gil = true; /* !PyC_IsInterpreterActive(); */
533
534   if (use_gil) {
535     gilstate = PyGILState_Ensure();
536   }
537
538   py_func = py_data[BPY_DATA_CB_SLOT_SET];
539
540   args = PyTuple_New(2);
541   self = pyrna_struct_as_instance(ptr);
542   PyTuple_SET_ITEM(args, 0, self);
543
544   py_values = PyC_Tuple_PackArray_Bool(values, len);
545   PyTuple_SET_ITEM(args, 1, py_values);
546
547   ret = PyObject_CallObject(py_func, args);
548
549   Py_DECREF(args);
550
551   if (ret == NULL) {
552     PyC_Err_PrintWithFunc(py_func);
553   }
554   else {
555     if (ret != Py_None) {
556       PyErr_SetString(PyExc_ValueError, "the return value must be None");
557       PyC_Err_PrintWithFunc(py_func);
558     }
559
560     Py_DECREF(ret);
561   }
562
563   if (use_gil) {
564     PyGILState_Release(gilstate);
565   }
566
567   if (!is_write_ok) {
568     pyrna_write_set(false);
569   }
570 }
571
572 static int bpy_prop_int_get_cb(struct PointerRNA *ptr, struct PropertyRNA *prop)
573 {
574   PyObject **py_data = RNA_property_py_data_get(prop);
575   PyObject *py_func;
576   PyObject *args;
577   PyObject *self;
578   PyObject *ret;
579   PyGILState_STATE gilstate;
580   bool use_gil;
581   const bool is_write_ok = pyrna_write_check();
582   int value;
583
584   BLI_assert(py_data != NULL);
585
586   if (!is_write_ok) {
587     pyrna_write_set(true);
588   }
589
590   use_gil = true; /* !PyC_IsInterpreterActive(); */
591
592   if (use_gil) {
593     gilstate = PyGILState_Ensure();
594   }
595
596   py_func = py_data[BPY_DATA_CB_SLOT_GET];
597
598   args = PyTuple_New(1);
599   self = pyrna_struct_as_instance(ptr);
600   PyTuple_SET_ITEM(args, 0, self);
601
602   ret = PyObject_CallObject(py_func, args);
603
604   Py_DECREF(args);
605
606   if (ret == NULL) {
607     PyC_Err_PrintWithFunc(py_func);
608     value = 0.0f;
609   }
610   else {
611     value = PyC_Long_AsI32(ret);
612
613     if (value == -1 && PyErr_Occurred()) {
614       PyC_Err_PrintWithFunc(py_func);
615       value = 0;
616     }
617
618     Py_DECREF(ret);
619   }
620
621   if (use_gil) {
622     PyGILState_Release(gilstate);
623   }
624
625   if (!is_write_ok) {
626     pyrna_write_set(false);
627   }
628
629   return value;
630 }
631
632 static void bpy_prop_int_set_cb(struct PointerRNA *ptr, struct PropertyRNA *prop, int value)
633 {
634   PyObject **py_data = RNA_property_py_data_get(prop);
635   PyObject *py_func;
636   PyObject *args;
637   PyObject *self;
638   PyObject *ret;
639   PyGILState_STATE gilstate;
640   bool use_gil;
641   const bool is_write_ok = pyrna_write_check();
642
643   BLI_assert(py_data != NULL);
644
645   if (!is_write_ok) {
646     pyrna_write_set(true);
647   }
648
649   use_gil = true; /* !PyC_IsInterpreterActive(); */
650
651   if (use_gil) {
652     gilstate = PyGILState_Ensure();
653   }
654
655   py_func = py_data[BPY_DATA_CB_SLOT_SET];
656
657   args = PyTuple_New(2);
658   self = pyrna_struct_as_instance(ptr);
659   PyTuple_SET_ITEM(args, 0, self);
660
661   PyTuple_SET_ITEM(args, 1, PyLong_FromLong(value));
662
663   ret = PyObject_CallObject(py_func, args);
664
665   Py_DECREF(args);
666
667   if (ret == NULL) {
668     PyC_Err_PrintWithFunc(py_func);
669   }
670   else {
671     if (ret != Py_None) {
672       PyErr_SetString(PyExc_ValueError, "the return value must be None");
673       PyC_Err_PrintWithFunc(py_func);
674     }
675
676     Py_DECREF(ret);
677   }
678
679   if (use_gil) {
680     PyGILState_Release(gilstate);
681   }
682
683   if (!is_write_ok) {
684     pyrna_write_set(false);
685   }
686 }
687
688 static void bpy_prop_int_array_get_cb(struct PointerRNA *ptr,
689                                       struct PropertyRNA *prop,
690                                       int *values)
691 {
692   PyObject **py_data = RNA_property_py_data_get(prop);
693   PyObject *py_func;
694   PyObject *args;
695   PyObject *self;
696   PyObject *ret;
697   PyGILState_STATE gilstate;
698   bool use_gil;
699   const bool is_write_ok = pyrna_write_check();
700   int i, len = RNA_property_array_length(ptr, prop);
701
702   BLI_assert(py_data != NULL);
703
704   if (!is_write_ok) {
705     pyrna_write_set(true);
706   }
707
708   use_gil = true; /* !PyC_IsInterpreterActive(); */
709
710   if (use_gil) {
711     gilstate = PyGILState_Ensure();
712   }
713
714   py_func = py_data[BPY_DATA_CB_SLOT_GET];
715
716   args = PyTuple_New(1);
717   self = pyrna_struct_as_instance(ptr);
718   PyTuple_SET_ITEM(args, 0, self);
719
720   ret = PyObject_CallObject(py_func, args);
721
722   Py_DECREF(args);
723
724   if (ret == NULL) {
725     PyC_Err_PrintWithFunc(py_func);
726
727     for (i = 0; i < len; ++i) {
728       values[i] = 0;
729     }
730   }
731   else {
732     if (PyC_AsArray(values, ret, len, &PyLong_Type, false, "IntVectorProperty get") == -1) {
733       PyC_Err_PrintWithFunc(py_func);
734
735       for (i = 0; i < len; ++i) {
736         values[i] = 0;
737       }
738
739       /* PyC_AsArray decrements refcount internally on error */
740     }
741     else {
742       Py_DECREF(ret);
743     }
744   }
745
746   if (use_gil) {
747     PyGILState_Release(gilstate);
748   }
749
750   if (!is_write_ok) {
751     pyrna_write_set(false);
752   }
753 }
754
755 static void bpy_prop_int_array_set_cb(struct PointerRNA *ptr,
756                                       struct PropertyRNA *prop,
757                                       const int *values)
758 {
759   PyObject **py_data = RNA_property_py_data_get(prop);
760   PyObject *py_func;
761   PyObject *args;
762   PyObject *self;
763   PyObject *ret;
764   PyObject *py_values;
765   PyGILState_STATE gilstate;
766   bool use_gil;
767   const bool is_write_ok = pyrna_write_check();
768   int len = RNA_property_array_length(ptr, prop);
769
770   BLI_assert(py_data != NULL);
771
772   if (!is_write_ok) {
773     pyrna_write_set(true);
774   }
775
776   use_gil = true; /* !PyC_IsInterpreterActive(); */
777
778   if (use_gil) {
779     gilstate = PyGILState_Ensure();
780   }
781
782   py_func = py_data[BPY_DATA_CB_SLOT_SET];
783
784   args = PyTuple_New(2);
785   self = pyrna_struct_as_instance(ptr);
786   PyTuple_SET_ITEM(args, 0, self);
787
788   py_values = PyC_Tuple_PackArray_I32(values, len);
789   PyTuple_SET_ITEM(args, 1, py_values);
790
791   ret = PyObject_CallObject(py_func, args);
792
793   Py_DECREF(args);
794
795   if (ret == NULL) {
796     PyC_Err_PrintWithFunc(py_func);
797   }
798   else {
799     if (ret != Py_None) {
800       PyErr_SetString(PyExc_ValueError, "the return value must be None");
801       PyC_Err_PrintWithFunc(py_func);
802     }
803
804     Py_DECREF(ret);
805   }
806
807   if (use_gil) {
808     PyGILState_Release(gilstate);
809   }
810
811   if (!is_write_ok) {
812     pyrna_write_set(false);
813   }
814 }
815
816 static float bpy_prop_float_get_cb(struct PointerRNA *ptr, struct PropertyRNA *prop)
817 {
818   PyObject **py_data = RNA_property_py_data_get(prop);
819   PyObject *py_func;
820   PyObject *args;
821   PyObject *self;
822   PyObject *ret;
823   PyGILState_STATE gilstate;
824   bool use_gil;
825   const bool is_write_ok = pyrna_write_check();
826   float value;
827
828   BLI_assert(py_data != NULL);
829
830   if (!is_write_ok) {
831     pyrna_write_set(true);
832   }
833
834   use_gil = true; /* !PyC_IsInterpreterActive(); */
835
836   if (use_gil) {
837     gilstate = PyGILState_Ensure();
838   }
839
840   py_func = py_data[BPY_DATA_CB_SLOT_GET];
841
842   args = PyTuple_New(1);
843   self = pyrna_struct_as_instance(ptr);
844   PyTuple_SET_ITEM(args, 0, self);
845
846   ret = PyObject_CallObject(py_func, args);
847
848   Py_DECREF(args);
849
850   if (ret == NULL) {
851     PyC_Err_PrintWithFunc(py_func);
852     value = 0.0f;
853   }
854   else {
855     value = PyFloat_AsDouble(ret);
856
857     if (value == -1.0f && PyErr_Occurred()) {
858       PyC_Err_PrintWithFunc(py_func);
859       value = 0.0f;
860     }
861
862     Py_DECREF(ret);
863   }
864
865   if (use_gil) {
866     PyGILState_Release(gilstate);
867   }
868
869   if (!is_write_ok) {
870     pyrna_write_set(false);
871   }
872
873   return value;
874 }
875
876 static void bpy_prop_float_set_cb(struct PointerRNA *ptr, struct PropertyRNA *prop, float value)
877 {
878   PyObject **py_data = RNA_property_py_data_get(prop);
879   PyObject *py_func;
880   PyObject *args;
881   PyObject *self;
882   PyObject *ret;
883   PyGILState_STATE gilstate;
884   bool use_gil;
885   const bool is_write_ok = pyrna_write_check();
886
887   BLI_assert(py_data != NULL);
888
889   if (!is_write_ok) {
890     pyrna_write_set(true);
891   }
892
893   use_gil = true; /* !PyC_IsInterpreterActive(); */
894
895   if (use_gil) {
896     gilstate = PyGILState_Ensure();
897   }
898
899   py_func = py_data[BPY_DATA_CB_SLOT_SET];
900
901   args = PyTuple_New(2);
902   self = pyrna_struct_as_instance(ptr);
903   PyTuple_SET_ITEM(args, 0, self);
904
905   PyTuple_SET_ITEM(args, 1, PyFloat_FromDouble(value));
906
907   ret = PyObject_CallObject(py_func, args);
908
909   Py_DECREF(args);
910
911   if (ret == NULL) {
912     PyC_Err_PrintWithFunc(py_func);
913   }
914   else {
915     if (ret != Py_None) {
916       PyErr_SetString(PyExc_ValueError, "the return value must be None");
917       PyC_Err_PrintWithFunc(py_func);
918     }
919
920     Py_DECREF(ret);
921   }
922
923   if (use_gil) {
924     PyGILState_Release(gilstate);
925   }
926
927   if (!is_write_ok) {
928     pyrna_write_set(false);
929   }
930 }
931
932 static void bpy_prop_float_array_get_cb(struct PointerRNA *ptr,
933                                         struct PropertyRNA *prop,
934                                         float *values)
935 {
936   PyObject **py_data = RNA_property_py_data_get(prop);
937   PyObject *py_func;
938   PyObject *args;
939   PyObject *self;
940   PyObject *ret;
941   PyGILState_STATE gilstate;
942   bool use_gil;
943   const bool is_write_ok = pyrna_write_check();
944   int i, len = RNA_property_array_length(ptr, prop);
945
946   BLI_assert(py_data != NULL);
947
948   if (!is_write_ok) {
949     pyrna_write_set(true);
950   }
951
952   use_gil = true; /* !PyC_IsInterpreterActive(); */
953
954   if (use_gil) {
955     gilstate = PyGILState_Ensure();
956   }
957
958   py_func = py_data[BPY_DATA_CB_SLOT_GET];
959
960   args = PyTuple_New(1);
961   self = pyrna_struct_as_instance(ptr);
962   PyTuple_SET_ITEM(args, 0, self);
963
964   ret = PyObject_CallObject(py_func, args);
965
966   Py_DECREF(args);
967
968   if (ret == NULL) {
969     PyC_Err_PrintWithFunc(py_func);
970
971     for (i = 0; i < len; ++i) {
972       values[i] = 0.0f;
973     }
974   }
975   else {
976     if (PyC_AsArray(values, ret, len, &PyFloat_Type, false, "FloatVectorProperty get") == -1) {
977       PyC_Err_PrintWithFunc(py_func);
978
979       for (i = 0; i < len; ++i) {
980         values[i] = 0.0f;
981       }
982
983       /* PyC_AsArray decrements refcount internally on error */
984     }
985     else {
986       Py_DECREF(ret);
987     }
988   }
989
990   if (use_gil) {
991     PyGILState_Release(gilstate);
992   }
993
994   if (!is_write_ok) {
995     pyrna_write_set(false);
996   }
997 }
998
999 static void bpy_prop_float_array_set_cb(struct PointerRNA *ptr,
1000                                         struct PropertyRNA *prop,
1001                                         const float *values)
1002 {
1003   PyObject **py_data = RNA_property_py_data_get(prop);
1004   PyObject *py_func;
1005   PyObject *args;
1006   PyObject *self;
1007   PyObject *ret;
1008   PyObject *py_values;
1009   PyGILState_STATE gilstate;
1010   bool use_gil;
1011   const bool is_write_ok = pyrna_write_check();
1012   int len = RNA_property_array_length(ptr, prop);
1013
1014   BLI_assert(py_data != NULL);
1015
1016   if (!is_write_ok) {
1017     pyrna_write_set(true);
1018   }
1019
1020   use_gil = true; /* !PyC_IsInterpreterActive(); */
1021
1022   if (use_gil) {
1023     gilstate = PyGILState_Ensure();
1024   }
1025
1026   py_func = py_data[BPY_DATA_CB_SLOT_SET];
1027
1028   args = PyTuple_New(2);
1029   self = pyrna_struct_as_instance(ptr);
1030   PyTuple_SET_ITEM(args, 0, self);
1031
1032   py_values = PyC_Tuple_PackArray_F32(values, len);
1033   PyTuple_SET_ITEM(args, 1, py_values);
1034
1035   ret = PyObject_CallObject(py_func, args);
1036
1037   Py_DECREF(args);
1038
1039   if (ret == NULL) {
1040     PyC_Err_PrintWithFunc(py_func);
1041   }
1042   else {
1043     if (ret != Py_None) {
1044       PyErr_SetString(PyExc_ValueError, "the return value must be None");
1045       PyC_Err_PrintWithFunc(py_func);
1046     }
1047
1048     Py_DECREF(ret);
1049   }
1050
1051   if (use_gil) {
1052     PyGILState_Release(gilstate);
1053   }
1054
1055   if (!is_write_ok) {
1056     pyrna_write_set(false);
1057   }
1058 }
1059
1060 static void bpy_prop_string_get_cb(struct PointerRNA *ptr, struct PropertyRNA *prop, char *value)
1061 {
1062   PyObject **py_data = RNA_property_py_data_get(prop);
1063   PyObject *py_func;
1064   PyObject *args;
1065   PyObject *self;
1066   PyObject *ret;
1067   PyGILState_STATE gilstate;
1068   bool use_gil;
1069   const bool is_write_ok = pyrna_write_check();
1070
1071   BLI_assert(py_data != NULL);
1072
1073   if (!is_write_ok) {
1074     pyrna_write_set(true);
1075   }
1076
1077   use_gil = true; /* !PyC_IsInterpreterActive(); */
1078
1079   if (use_gil) {
1080     gilstate = PyGILState_Ensure();
1081   }
1082
1083   py_func = py_data[BPY_DATA_CB_SLOT_GET];
1084
1085   args = PyTuple_New(1);
1086   self = pyrna_struct_as_instance(ptr);
1087   PyTuple_SET_ITEM(args, 0, self);
1088
1089   ret = PyObject_CallObject(py_func, args);
1090
1091   Py_DECREF(args);
1092
1093   if (ret == NULL) {
1094     PyC_Err_PrintWithFunc(py_func);
1095     value[0] = '\0';
1096   }
1097   else if (!PyUnicode_Check(ret)) {
1098     PyErr_Format(
1099         PyExc_TypeError, "return value must be a string, not %.200s", Py_TYPE(ret)->tp_name);
1100     PyC_Err_PrintWithFunc(py_func);
1101     value[0] = '\0';
1102     Py_DECREF(ret);
1103   }
1104   else {
1105     Py_ssize_t length;
1106     const char *buffer = _PyUnicode_AsStringAndSize(ret, &length);
1107     memcpy(value, buffer, length + 1);
1108     Py_DECREF(ret);
1109   }
1110
1111   if (use_gil) {
1112     PyGILState_Release(gilstate);
1113   }
1114
1115   if (!is_write_ok) {
1116     pyrna_write_set(false);
1117   }
1118 }
1119
1120 static int bpy_prop_string_length_cb(struct PointerRNA *ptr, struct PropertyRNA *prop)
1121 {
1122   PyObject **py_data = RNA_property_py_data_get(prop);
1123   PyObject *py_func;
1124   PyObject *args;
1125   PyObject *self;
1126   PyObject *ret;
1127   PyGILState_STATE gilstate;
1128   bool use_gil;
1129   const bool is_write_ok = pyrna_write_check();
1130   int length;
1131
1132   BLI_assert(py_data != NULL);
1133
1134   if (!is_write_ok) {
1135     pyrna_write_set(true);
1136   }
1137
1138   use_gil = true; /* !PyC_IsInterpreterActive(); */
1139
1140   if (use_gil) {
1141     gilstate = PyGILState_Ensure();
1142   }
1143
1144   py_func = py_data[BPY_DATA_CB_SLOT_GET];
1145
1146   args = PyTuple_New(1);
1147   self = pyrna_struct_as_instance(ptr);
1148   PyTuple_SET_ITEM(args, 0, self);
1149
1150   ret = PyObject_CallObject(py_func, args);
1151
1152   Py_DECREF(args);
1153
1154   if (ret == NULL) {
1155     PyC_Err_PrintWithFunc(py_func);
1156     length = 0;
1157   }
1158   else if (!PyUnicode_Check(ret)) {
1159     PyErr_Format(
1160         PyExc_TypeError, "return value must be a string, not %.200s", Py_TYPE(ret)->tp_name);
1161     PyC_Err_PrintWithFunc(py_func);
1162     length = 0;
1163     Py_DECREF(ret);
1164   }
1165   else {
1166     Py_ssize_t length_ssize_t = 0;
1167     _PyUnicode_AsStringAndSize(ret, &length_ssize_t);
1168     length = length_ssize_t;
1169     Py_DECREF(ret);
1170   }
1171
1172   if (use_gil) {
1173     PyGILState_Release(gilstate);
1174   }
1175
1176   if (!is_write_ok) {
1177     pyrna_write_set(false);
1178   }
1179
1180   return length;
1181 }
1182
1183 static void bpy_prop_string_set_cb(struct PointerRNA *ptr,
1184                                    struct PropertyRNA *prop,
1185                                    const char *value)
1186 {
1187   PyObject **py_data = RNA_property_py_data_get(prop);
1188   PyObject *py_func;
1189   PyObject *args;
1190   PyObject *self;
1191   PyObject *ret;
1192   PyGILState_STATE gilstate;
1193   bool use_gil;
1194   const bool is_write_ok = pyrna_write_check();
1195   PyObject *py_value;
1196
1197   BLI_assert(py_data != NULL);
1198
1199   if (!is_write_ok) {
1200     pyrna_write_set(true);
1201   }
1202
1203   use_gil = true; /* !PyC_IsInterpreterActive(); */
1204
1205   if (use_gil) {
1206     gilstate = PyGILState_Ensure();
1207   }
1208
1209   py_func = py_data[BPY_DATA_CB_SLOT_SET];
1210
1211   args = PyTuple_New(2);
1212   self = pyrna_struct_as_instance(ptr);
1213   PyTuple_SET_ITEM(args, 0, self);
1214
1215   py_value = PyUnicode_FromString(value);
1216   if (!py_value) {
1217     PyErr_SetString(PyExc_ValueError, "the return value must be a string");
1218     PyC_Err_PrintWithFunc(py_func);
1219   }
1220   else {
1221     PyTuple_SET_ITEM(args, 1, py_value);
1222   }
1223
1224   ret = PyObject_CallObject(py_func, args);
1225
1226   Py_DECREF(args);
1227
1228   if (ret == NULL) {
1229     PyC_Err_PrintWithFunc(py_func);
1230   }
1231   else {
1232     if (ret != Py_None) {
1233       PyErr_SetString(PyExc_ValueError, "the return value must be None");
1234       PyC_Err_PrintWithFunc(py_func);
1235     }
1236
1237     Py_DECREF(ret);
1238   }
1239
1240   if (use_gil) {
1241     PyGILState_Release(gilstate);
1242   }
1243
1244   if (!is_write_ok) {
1245     pyrna_write_set(false);
1246   }
1247 }
1248
1249 static int bpy_prop_enum_get_cb(struct PointerRNA *ptr, struct PropertyRNA *prop)
1250 {
1251   PyObject **py_data = RNA_property_py_data_get(prop);
1252   PyObject *py_func;
1253   PyObject *args;
1254   PyObject *self;
1255   PyObject *ret;
1256   PyGILState_STATE gilstate;
1257   bool use_gil;
1258   const bool is_write_ok = pyrna_write_check();
1259   int value;
1260
1261   BLI_assert(py_data != NULL);
1262
1263   if (!is_write_ok) {
1264     pyrna_write_set(true);
1265   }
1266
1267   use_gil = true; /* !PyC_IsInterpreterActive(); */
1268
1269   if (use_gil) {
1270     gilstate = PyGILState_Ensure();
1271   }
1272
1273   py_func = py_data[BPY_DATA_CB_SLOT_GET];
1274
1275   args = PyTuple_New(1);
1276   self = pyrna_struct_as_instance(ptr);
1277   PyTuple_SET_ITEM(args, 0, self);
1278
1279   ret = PyObject_CallObject(py_func, args);
1280
1281   Py_DECREF(args);
1282
1283   if (ret == NULL) {
1284     PyC_Err_PrintWithFunc(py_func);
1285     value = RNA_property_enum_get_default(ptr, prop);
1286   }
1287   else {
1288     value = PyC_Long_AsI32(ret);
1289
1290     if (value == -1 && PyErr_Occurred()) {
1291       PyC_Err_PrintWithFunc(py_func);
1292       value = RNA_property_enum_get_default(ptr, prop);
1293     }
1294
1295     Py_DECREF(ret);
1296   }
1297
1298   if (use_gil) {
1299     PyGILState_Release(gilstate);
1300   }
1301
1302   if (!is_write_ok) {
1303     pyrna_write_set(false);
1304   }
1305
1306   return value;
1307 }
1308
1309 static void bpy_prop_enum_set_cb(struct PointerRNA *ptr, struct PropertyRNA *prop, int value)
1310 {
1311   PyObject **py_data = RNA_property_py_data_get(prop);
1312   PyObject *py_func;
1313   PyObject *args;
1314   PyObject *self;
1315   PyObject *ret;
1316   PyGILState_STATE gilstate;
1317   bool use_gil;
1318   const bool is_write_ok = pyrna_write_check();
1319
1320   BLI_assert(py_data != NULL);
1321
1322   if (!is_write_ok) {
1323     pyrna_write_set(true);
1324   }
1325
1326   use_gil = true; /* !PyC_IsInterpreterActive(); */
1327
1328   if (use_gil) {
1329     gilstate = PyGILState_Ensure();
1330   }
1331
1332   py_func = py_data[BPY_DATA_CB_SLOT_SET];
1333
1334   args = PyTuple_New(2);
1335   self = pyrna_struct_as_instance(ptr);
1336   PyTuple_SET_ITEM(args, 0, self);
1337
1338   PyTuple_SET_ITEM(args, 1, PyLong_FromLong(value));
1339
1340   ret = PyObject_CallObject(py_func, args);
1341
1342   Py_DECREF(args);
1343
1344   if (ret == NULL) {
1345     PyC_Err_PrintWithFunc(py_func);
1346   }
1347   else {
1348     if (ret != Py_None) {
1349       PyErr_SetString(PyExc_ValueError, "the return value must be None");
1350       PyC_Err_PrintWithFunc(py_func);
1351     }
1352
1353     Py_DECREF(ret);
1354   }
1355
1356   if (use_gil) {
1357     PyGILState_Release(gilstate);
1358   }
1359
1360   if (!is_write_ok) {
1361     pyrna_write_set(false);
1362   }
1363 }
1364
1365 /* utility function we need for parsing int's in an if statement */
1366 static int py_long_as_int(PyObject *py_long, int *r_int)
1367 {
1368   if (PyLong_CheckExact(py_long)) {
1369     *r_int = (int)PyLong_AS_LONG(py_long);
1370     return 0;
1371   }
1372   else {
1373     return -1;
1374   }
1375 }
1376
1377 #if 0
1378 /* copies orig to buf, then sets orig to buf, returns copy length */
1379 static size_t strswapbufcpy(char *buf, const char **orig)
1380 {
1381   const char *src = *orig;
1382   char *dst = buf;
1383   size_t i = 0;
1384   *orig = buf;
1385   while ((*dst = *src)) {
1386     dst++;
1387     src++;
1388     i++;
1389   }
1390   return i + 1; /* include '\0' */
1391 }
1392 #endif
1393
1394 static int icon_id_from_name(const char *name)
1395 {
1396   const EnumPropertyItem *item;
1397   int id;
1398
1399   if (name[0]) {
1400     for (item = rna_enum_icon_items, id = 0; item->identifier; item++, id++) {
1401       if (STREQ(item->name, name)) {
1402         return item->value;
1403       }
1404     }
1405   }
1406
1407   return 0;
1408 }
1409
1410 static const EnumPropertyItem *enum_items_from_py(PyObject *seq_fast,
1411                                                   PyObject *def,
1412                                                   int *defvalue,
1413                                                   const bool is_enum_flag)
1414 {
1415   EnumPropertyItem *items;
1416   PyObject *item;
1417   const Py_ssize_t seq_len = PySequence_Fast_GET_SIZE(seq_fast);
1418   PyObject **seq_fast_items = PySequence_Fast_ITEMS(seq_fast);
1419   Py_ssize_t totbuf = 0;
1420   int i;
1421   short def_used = 0;
1422   const char *def_cmp = NULL;
1423
1424   if (is_enum_flag) {
1425     if (seq_len > RNA_ENUM_BITFLAG_SIZE) {
1426       PyErr_SetString(PyExc_TypeError,
1427                       "EnumProperty(...): maximum " STRINGIFY(
1428                           RNA_ENUM_BITFLAG_SIZE) " members for a ENUM_FLAG type property");
1429       return NULL;
1430     }
1431     if (def && !PySet_Check(def)) {
1432       PyErr_Format(PyExc_TypeError,
1433                    "EnumProperty(...): default option must be a 'set' "
1434                    "type when ENUM_FLAG is enabled, not a '%.200s'",
1435                    Py_TYPE(def)->tp_name);
1436       return NULL;
1437     }
1438   }
1439   else {
1440     if (def) {
1441       def_cmp = _PyUnicode_AsString(def);
1442       if (def_cmp == NULL) {
1443         PyErr_Format(PyExc_TypeError,
1444                      "EnumProperty(...): default option must be a 'str' "
1445                      "type when ENUM_FLAG is disabled, not a '%.200s'",
1446                      Py_TYPE(def)->tp_name);
1447         return NULL;
1448       }
1449     }
1450   }
1451
1452   /* blank value */
1453   *defvalue = 0;
1454
1455   items = MEM_callocN(sizeof(EnumPropertyItem) * (seq_len + 1), "enum_items_from_py1");
1456
1457   for (i = 0; i < seq_len; i++) {
1458     EnumPropertyItem tmp = {0, "", 0, "", ""};
1459     const char *tmp_icon = NULL;
1460     Py_ssize_t item_size;
1461     Py_ssize_t id_str_size;
1462     Py_ssize_t name_str_size;
1463     Py_ssize_t desc_str_size;
1464
1465     item = seq_fast_items[i];
1466
1467     if ((PyTuple_CheckExact(item)) && (item_size = PyTuple_GET_SIZE(item)) &&
1468         (item_size >= 3 && item_size <= 5) &&
1469         (tmp.identifier = _PyUnicode_AsStringAndSize(PyTuple_GET_ITEM(item, 0), &id_str_size)) &&
1470         (tmp.name = _PyUnicode_AsStringAndSize(PyTuple_GET_ITEM(item, 1), &name_str_size)) &&
1471         (tmp.description = _PyUnicode_AsStringAndSize(PyTuple_GET_ITEM(item, 2),
1472                                                       &desc_str_size)) &&
1473         /* TODO, number isn't ensured to be unique from the script author */
1474         (item_size != 4 || py_long_as_int(PyTuple_GET_ITEM(item, 3), &tmp.value) != -1) &&
1475         (item_size != 5 || ((py_long_as_int(PyTuple_GET_ITEM(item, 3), &tmp.icon) != -1 ||
1476                              (tmp_icon = _PyUnicode_AsString(PyTuple_GET_ITEM(item, 3)))) &&
1477                             py_long_as_int(PyTuple_GET_ITEM(item, 4), &tmp.value) != -1))) {
1478       if (is_enum_flag) {
1479         if (item_size < 4) {
1480           tmp.value = 1 << i;
1481         }
1482
1483         if (def && PySet_Contains(def, PyTuple_GET_ITEM(item, 0))) {
1484           *defvalue |= tmp.value;
1485           def_used++;
1486         }
1487       }
1488       else {
1489         if (item_size < 4) {
1490           tmp.value = i;
1491         }
1492
1493         if (def && def_used == 0 && STREQ(def_cmp, tmp.identifier)) {
1494           *defvalue = tmp.value;
1495           def_used++; /* only ever 1 */
1496         }
1497       }
1498
1499       if (tmp_icon) {
1500         tmp.icon = icon_id_from_name(tmp_icon);
1501       }
1502
1503       items[i] = tmp;
1504
1505       /* calculate combine string length */
1506       totbuf += id_str_size + name_str_size + desc_str_size + 3; /* 3 is for '\0's */
1507     }
1508     else {
1509       MEM_freeN(items);
1510       PyErr_SetString(PyExc_TypeError,
1511                       "EnumProperty(...): expected a tuple containing "
1512                       "(identifier, name, description) and optionally an "
1513                       "icon name and unique number");
1514       return NULL;
1515     }
1516   }
1517
1518   if (is_enum_flag) {
1519     /* strict check that all set members were used */
1520     if (def && def_used != PySet_GET_SIZE(def)) {
1521       MEM_freeN(items);
1522
1523       PyErr_Format(PyExc_TypeError,
1524                    "EnumProperty(..., default={...}): set has %d unused member(s)",
1525                    PySet_GET_SIZE(def) - def_used);
1526       return NULL;
1527     }
1528   }
1529   else {
1530     if (def && def_used == 0) {
1531       MEM_freeN(items);
1532
1533       PyErr_Format(PyExc_TypeError,
1534                    "EnumProperty(..., default=\'%s\'): not found in enum members",
1535                    def_cmp);
1536       return NULL;
1537     }
1538   }
1539
1540   /* disabled duplicating strings because the array can still be freed and
1541    * the strings from it referenced, for now we can't support dynamically
1542    * created strings from python. */
1543 #if 0
1544   /* this would all work perfectly _but_ the python strings may be freed
1545    * immediately after use, so we need to duplicate them, ugh.
1546    * annoying because it works most of the time without this. */
1547   {
1548     EnumPropertyItem *items_dup = MEM_mallocN((sizeof(EnumPropertyItem) * (seq_len + 1)) +
1549                                                   (sizeof(char) * totbuf),
1550                                               "enum_items_from_py2");
1551     EnumPropertyItem *items_ptr = items_dup;
1552     char *buf = ((char *)items_dup) + (sizeof(EnumPropertyItem) * (seq_len + 1));
1553     memcpy(items_dup, items, sizeof(EnumPropertyItem) * (seq_len + 1));
1554     for (i = 0; i < seq_len; i++, items_ptr++) {
1555       buf += strswapbufcpy(buf, &items_ptr->identifier);
1556       buf += strswapbufcpy(buf, &items_ptr->name);
1557       buf += strswapbufcpy(buf, &items_ptr->description);
1558     }
1559     MEM_freeN(items);
1560     items = items_dup;
1561   }
1562   /* end string duplication */
1563 #endif
1564
1565   return items;
1566 }
1567
1568 static const EnumPropertyItem *bpy_prop_enum_itemf_cb(struct bContext *C,
1569                                                       PointerRNA *ptr,
1570                                                       PropertyRNA *prop,
1571                                                       bool *r_free)
1572 {
1573   PyGILState_STATE gilstate;
1574
1575   PyObject *py_func = RNA_property_enum_py_data_get(prop);
1576   PyObject *self = NULL;
1577   PyObject *args;
1578   PyObject *items; /* returned from the function call */
1579
1580   const EnumPropertyItem *eitems = NULL;
1581   int err = 0;
1582
1583   if (C) {
1584     bpy_context_set(C, &gilstate);
1585   }
1586   else {
1587     gilstate = PyGILState_Ensure();
1588   }
1589
1590   args = PyTuple_New(2);
1591   self = pyrna_struct_as_instance(ptr);
1592   PyTuple_SET_ITEM(args, 0, self);
1593
1594   /* now get the context */
1595   if (C) {
1596     PyTuple_SET_ITEM(args, 1, (PyObject *)bpy_context_module);
1597     Py_INCREF(bpy_context_module);
1598   }
1599   else {
1600     PyTuple_SET_ITEM(args, 1, Py_None);
1601     Py_INCREF(Py_None);
1602   }
1603
1604   items = PyObject_CallObject(py_func, args);
1605
1606   Py_DECREF(args);
1607
1608   if (items == NULL) {
1609     err = -1;
1610   }
1611   else {
1612     PyObject *items_fast;
1613     int defvalue_dummy = 0;
1614
1615     if (!(items_fast = PySequence_Fast(items,
1616                                        "EnumProperty(...): "
1617                                        "return value from the callback was not a sequence"))) {
1618       err = -1;
1619     }
1620     else {
1621       eitems = enum_items_from_py(
1622           items_fast, NULL, &defvalue_dummy, (RNA_property_flag(prop) & PROP_ENUM_FLAG) != 0);
1623
1624       Py_DECREF(items_fast);
1625
1626       if (!eitems) {
1627         err = -1;
1628       }
1629     }
1630
1631     Py_DECREF(items);
1632   }
1633
1634   if (err != -1) { /* worked */
1635     *r_free = true;
1636   }
1637   else {
1638     PyC_Err_PrintWithFunc(py_func);
1639
1640     eitems = DummyRNA_NULL_items;
1641   }
1642
1643   if (C) {
1644     bpy_context_clear(C, &gilstate);
1645   }
1646   else {
1647     PyGILState_Release(gilstate);
1648   }
1649
1650   return eitems;
1651 }
1652
1653 static int bpy_prop_callback_check(PyObject *py_func, const char *keyword, int argcount)
1654 {
1655   if (py_func && py_func != Py_None) {
1656     if (!PyFunction_Check(py_func)) {
1657       PyErr_Format(PyExc_TypeError,
1658                    "%s keyword: expected a function type, not a %.200s",
1659                    keyword,
1660                    Py_TYPE(py_func)->tp_name);
1661       return -1;
1662     }
1663     else {
1664       PyCodeObject *f_code = (PyCodeObject *)PyFunction_GET_CODE(py_func);
1665       if (f_code->co_argcount != argcount) {
1666         PyErr_Format(PyExc_TypeError,
1667                      "%s keyword: expected a function taking %d arguments, not %d",
1668                      keyword,
1669                      argcount,
1670                      f_code->co_argcount);
1671         return -1;
1672       }
1673     }
1674   }
1675
1676   return 0;
1677 }
1678
1679 static PyObject **bpy_prop_py_data_get(struct PropertyRNA *prop)
1680 {
1681   PyObject **py_data = RNA_property_py_data_get(prop);
1682   if (!py_data) {
1683     py_data = MEM_callocN(sizeof(PyObject *) * BPY_DATA_CB_SLOT_SIZE, __func__);
1684     RNA_def_py_data(prop, py_data);
1685   }
1686   return py_data;
1687 }
1688
1689 static void bpy_prop_callback_assign_update(struct PropertyRNA *prop, PyObject *update_cb)
1690 {
1691   /* assume this is already checked for type and arg length */
1692   if (update_cb && update_cb != Py_None) {
1693     PyObject **py_data = bpy_prop_py_data_get(prop);
1694
1695     RNA_def_property_update_runtime(prop, (void *)bpy_prop_update_cb);
1696     py_data[BPY_DATA_CB_SLOT_UPDATE] = update_cb;
1697
1698     RNA_def_property_flag(prop, PROP_CONTEXT_PROPERTY_UPDATE);
1699   }
1700 }
1701
1702 static void bpy_prop_callback_assign_pointer(struct PropertyRNA *prop, PyObject *poll_cb)
1703 {
1704   if (poll_cb && poll_cb != Py_None) {
1705     PyObject **py_data = bpy_prop_py_data_get(prop);
1706
1707     RNA_def_property_poll_runtime(prop, (void *)bpy_prop_poll_cb);
1708     py_data[BPY_DATA_CB_SLOT_POLL] = poll_cb;
1709   }
1710 }
1711
1712 static void bpy_prop_callback_assign_boolean(struct PropertyRNA *prop,
1713                                              PyObject *get_cb,
1714                                              PyObject *set_cb)
1715 {
1716   BooleanPropertyGetFunc rna_get_cb = NULL;
1717   BooleanPropertySetFunc rna_set_cb = NULL;
1718
1719   if (get_cb && get_cb != Py_None) {
1720     PyObject **py_data = bpy_prop_py_data_get(prop);
1721
1722     rna_get_cb = bpy_prop_boolean_get_cb;
1723     py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
1724   }
1725
1726   if (set_cb && set_cb != Py_None) {
1727     PyObject **py_data = bpy_prop_py_data_get(prop);
1728
1729     rna_set_cb = bpy_prop_boolean_set_cb;
1730     py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
1731   }
1732
1733   RNA_def_property_boolean_funcs_runtime(prop, rna_get_cb, rna_set_cb);
1734 }
1735
1736 static void bpy_prop_callback_assign_boolean_array(struct PropertyRNA *prop,
1737                                                    PyObject *get_cb,
1738                                                    PyObject *set_cb)
1739 {
1740   BooleanArrayPropertyGetFunc rna_get_cb = NULL;
1741   BooleanArrayPropertySetFunc rna_set_cb = NULL;
1742
1743   if (get_cb && get_cb != Py_None) {
1744     PyObject **py_data = bpy_prop_py_data_get(prop);
1745
1746     rna_get_cb = bpy_prop_boolean_array_get_cb;
1747     py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
1748   }
1749
1750   if (set_cb && set_cb != Py_None) {
1751     PyObject **py_data = bpy_prop_py_data_get(prop);
1752
1753     rna_set_cb = bpy_prop_boolean_array_set_cb;
1754     py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
1755   }
1756
1757   RNA_def_property_boolean_array_funcs_runtime(prop, rna_get_cb, rna_set_cb);
1758 }
1759
1760 static void bpy_prop_callback_assign_int(struct PropertyRNA *prop,
1761                                          PyObject *get_cb,
1762                                          PyObject *set_cb)
1763 {
1764   IntPropertyGetFunc rna_get_cb = NULL;
1765   IntPropertySetFunc rna_set_cb = NULL;
1766
1767   if (get_cb && get_cb != Py_None) {
1768     PyObject **py_data = bpy_prop_py_data_get(prop);
1769
1770     rna_get_cb = bpy_prop_int_get_cb;
1771     py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
1772   }
1773
1774   if (set_cb && set_cb != Py_None) {
1775     PyObject **py_data = bpy_prop_py_data_get(prop);
1776
1777     rna_set_cb = bpy_prop_int_set_cb;
1778     py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
1779   }
1780
1781   RNA_def_property_int_funcs_runtime(prop, rna_get_cb, rna_set_cb, NULL);
1782 }
1783
1784 static void bpy_prop_callback_assign_int_array(struct PropertyRNA *prop,
1785                                                PyObject *get_cb,
1786                                                PyObject *set_cb)
1787 {
1788   IntArrayPropertyGetFunc rna_get_cb = NULL;
1789   IntArrayPropertySetFunc rna_set_cb = NULL;
1790
1791   if (get_cb && get_cb != Py_None) {
1792     PyObject **py_data = bpy_prop_py_data_get(prop);
1793
1794     rna_get_cb = bpy_prop_int_array_get_cb;
1795     py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
1796   }
1797
1798   if (set_cb && set_cb != Py_None) {
1799     PyObject **py_data = bpy_prop_py_data_get(prop);
1800
1801     rna_set_cb = bpy_prop_int_array_set_cb;
1802     py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
1803   }
1804
1805   RNA_def_property_int_array_funcs_runtime(prop, rna_get_cb, rna_set_cb, NULL);
1806 }
1807
1808 static void bpy_prop_callback_assign_float(struct PropertyRNA *prop,
1809                                            PyObject *get_cb,
1810                                            PyObject *set_cb)
1811 {
1812   FloatPropertyGetFunc rna_get_cb = NULL;
1813   FloatPropertySetFunc rna_set_cb = NULL;
1814
1815   if (get_cb && get_cb != Py_None) {
1816     PyObject **py_data = bpy_prop_py_data_get(prop);
1817
1818     rna_get_cb = bpy_prop_float_get_cb;
1819     py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
1820   }
1821
1822   if (set_cb && set_cb != Py_None) {
1823     PyObject **py_data = bpy_prop_py_data_get(prop);
1824
1825     rna_set_cb = bpy_prop_float_set_cb;
1826     py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
1827   }
1828
1829   RNA_def_property_float_funcs_runtime(prop, rna_get_cb, rna_set_cb, NULL);
1830 }
1831
1832 static void bpy_prop_callback_assign_float_array(struct PropertyRNA *prop,
1833                                                  PyObject *get_cb,
1834                                                  PyObject *set_cb)
1835 {
1836   FloatArrayPropertyGetFunc rna_get_cb = NULL;
1837   FloatArrayPropertySetFunc rna_set_cb = NULL;
1838
1839   if (get_cb && get_cb != Py_None) {
1840     PyObject **py_data = bpy_prop_py_data_get(prop);
1841
1842     rna_get_cb = bpy_prop_float_array_get_cb;
1843     py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
1844   }
1845
1846   if (set_cb && set_cb != Py_None) {
1847     PyObject **py_data = bpy_prop_py_data_get(prop);
1848
1849     rna_set_cb = bpy_prop_float_array_set_cb;
1850     py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
1851   }
1852
1853   RNA_def_property_float_array_funcs_runtime(prop, rna_get_cb, rna_set_cb, NULL);
1854 }
1855
1856 static void bpy_prop_callback_assign_string(struct PropertyRNA *prop,
1857                                             PyObject *get_cb,
1858                                             PyObject *set_cb)
1859 {
1860   StringPropertyGetFunc rna_get_cb = NULL;
1861   StringPropertyLengthFunc rna_length_cb = NULL;
1862   StringPropertySetFunc rna_set_cb = NULL;
1863
1864   if (get_cb && get_cb != Py_None) {
1865     PyObject **py_data = bpy_prop_py_data_get(prop);
1866
1867     rna_get_cb = bpy_prop_string_get_cb;
1868     rna_length_cb = bpy_prop_string_length_cb;
1869     py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
1870   }
1871
1872   if (set_cb && set_cb != Py_None) {
1873     PyObject **py_data = bpy_prop_py_data_get(prop);
1874
1875     rna_set_cb = bpy_prop_string_set_cb;
1876     py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
1877   }
1878
1879   RNA_def_property_string_funcs_runtime(prop, rna_get_cb, rna_length_cb, rna_set_cb);
1880 }
1881
1882 static void bpy_prop_callback_assign_enum(struct PropertyRNA *prop,
1883                                           PyObject *get_cb,
1884                                           PyObject *set_cb,
1885                                           PyObject *itemf_cb)
1886 {
1887   EnumPropertyGetFunc rna_get_cb = NULL;
1888   EnumPropertyItemFunc rna_itemf_cb = NULL;
1889   EnumPropertySetFunc rna_set_cb = NULL;
1890
1891   if (get_cb && get_cb != Py_None) {
1892     PyObject **py_data = bpy_prop_py_data_get(prop);
1893
1894     rna_get_cb = bpy_prop_enum_get_cb;
1895     py_data[BPY_DATA_CB_SLOT_GET] = get_cb;
1896   }
1897
1898   if (set_cb && set_cb != Py_None) {
1899     PyObject **py_data = bpy_prop_py_data_get(prop);
1900
1901     rna_set_cb = bpy_prop_enum_set_cb;
1902     py_data[BPY_DATA_CB_SLOT_SET] = set_cb;
1903   }
1904
1905   if (itemf_cb && itemf_cb != Py_None) {
1906     rna_itemf_cb = bpy_prop_enum_itemf_cb;
1907     RNA_def_property_enum_py_data(prop, (void *)itemf_cb);
1908
1909     /* watch out!, if a user is tricky they can probably crash blender
1910      * if they manage to free the callback, take care! */
1911     /* Py_INCREF(itemf_cb); */
1912   }
1913
1914   RNA_def_property_enum_funcs_runtime(prop, rna_get_cb, rna_set_cb, rna_itemf_cb);
1915 }
1916
1917 /* this define runs at the start of each function and deals with
1918  * returning a deferred property (to be registered later) */
1919 #define BPY_PROPDEF_HEAD(_func) \
1920   if (PyTuple_GET_SIZE(args) == 1) { \
1921     PyObject *ret; \
1922     self = PyTuple_GET_ITEM(args, 0); \
1923     args = PyTuple_New(0); \
1924     ret = BPy_##_func(self, args, kw); \
1925     Py_DECREF(args); \
1926     return ret; \
1927   } \
1928   else if (PyTuple_GET_SIZE(args) > 1) { \
1929     PyErr_SetString(PyExc_ValueError, "all args must be keywords"); \
1930     return NULL; \
1931   } \
1932   srna = srna_from_self(self, #_func "(...):"); \
1933   if (srna == NULL) { \
1934     if (PyErr_Occurred()) \
1935       return NULL; \
1936     return bpy_prop_deferred_return(pymeth_##_func, kw); \
1937   } \
1938   (void)0
1939
1940 /* terse macros for error checks shared between all funcs cant use function
1941  * calls because of static strings passed to pyrna_set_to_enum_bitfield */
1942 #define BPY_PROPDEF_CHECK(_func, _property_flag_items) \
1943   if (UNLIKELY(id_len >= MAX_IDPROP_NAME)) { \
1944     PyErr_Format(PyExc_TypeError, \
1945                  #_func "(): '%.200s' too long, max length is %d", \
1946                  id, \
1947                  MAX_IDPROP_NAME - 1); \
1948     return NULL; \
1949   } \
1950   if (UNLIKELY(RNA_def_property_free_identifier(srna, id) == -1)) { \
1951     PyErr_Format(PyExc_TypeError, #_func "(): '%s' is defined as a non-dynamic type", id); \
1952     return NULL; \
1953   } \
1954   if (UNLIKELY(pyopts && pyrna_set_to_enum_bitfield( \
1955                              _property_flag_items, pyopts, &opts, #_func "(options={ ...}):"))) { \
1956     return NULL; \
1957   } \
1958   { \
1959     const EnumPropertyItem *tag_defines = RNA_struct_property_tag_defines(srna); \
1960     if (py_tags && !tag_defines) { \
1961       PyErr_Format(PyExc_TypeError, \
1962                    #_func "(): property-tags not available for '%s'", \
1963                    RNA_struct_identifier(srna)); \
1964       return NULL; \
1965     } \
1966     if (UNLIKELY(py_tags && pyrna_set_to_enum_bitfield( \
1967                                 tag_defines, py_tags, &prop_tags, #_func "(tags={ ...}):"))) { \
1968       return NULL; \
1969     } \
1970   } \
1971   (void)0
1972
1973 #define BPY_PROPDEF_SUBTYPE_CHECK(_func, _property_flag_items, _subtype) \
1974   BPY_PROPDEF_CHECK(_func, _property_flag_items); \
1975   if (UNLIKELY(pysubtype && RNA_enum_value_from_id(_subtype, pysubtype, &subtype) == 0)) { \
1976     const char *enum_str = BPy_enum_as_string(_subtype); \
1977     PyErr_Format(PyExc_TypeError, \
1978                  #_func \
1979                  "(subtype='%s'): " \
1980                  "subtype not found in (%s)", \
1981                  pysubtype, \
1982                  enum_str); \
1983     MEM_freeN((void *)enum_str); \
1984     return NULL; \
1985   } \
1986   (void)0
1987
1988 #define BPY_PROPDEF_NAME_DOC \
1989   "   :arg name: Name used in the user interface.\n" \
1990   "   :type name: string\n"
1991
1992 #define BPY_PROPDEF_DESC_DOC \
1993   "   :arg description: Text used for the tooltip and api documentation.\n" \
1994   "   :type description: string\n"
1995
1996 #define BPY_PROPDEF_UNIT_DOC \
1997   "   :arg unit: Enumerator in ['NONE', 'LENGTH', 'AREA', 'VOLUME', 'ROTATION', 'TIME', " \
1998   "'VELOCITY', 'ACCELERATION', 'MASS', 'CAMERA', 'POWER'].\n" \
1999   "   :type unit: string\n"
2000
2001 #define BPY_PROPDEF_NUM_MIN_DOC \
2002   "   :arg min: Hard minimum, trying to assign a value below will silently assign this minimum " \
2003   "instead.\n"
2004
2005 #define BPY_PROPDEF_NUM_MAX_DOC \
2006   "   :arg max: Hard maximum, trying to assign a value above will silently assign this maximum " \
2007   "instead.\n"
2008
2009 #define BPY_PROPDEF_NUM_SOFTMIN_DOC \
2010   "   :arg soft_min: Soft minimum (>= *min*), user won't be able to drag the widget below this " \
2011   "value in the UI.\n"
2012
2013 #define BPY_PROPDEF_NUM_SOFTMAX_DOC \
2014   "   :arg soft_max: Soft maximum (<= *max*), user won't be able to drag the widget above this " \
2015   "value in the UI.\n"
2016
2017 #define BPY_PROPDEF_VECSIZE_DOC \
2018   "   :arg size: Vector dimensions in [1, " STRINGIFY(PYRNA_STACK_ARRAY) "].\n" \
2019 "   :type size: int\n"
2020
2021 #define BPY_PROPDEF_INT_STEP_DOC \
2022   "   :arg step: Step of increment/decrement in UI, in [1, 100], defaults to 1 (WARNING: unused " \
2023   "currently!).\n" \
2024   "   :type step: int\n"
2025
2026 #define BPY_PROPDEF_FLOAT_STEP_DOC \
2027   "   :arg step: Step of increment/decrement in UI, in [1, 100], defaults to 3 (WARNING: actual " \
2028   "value is /100).\n" \
2029   "   :type step: int\n"
2030
2031 #define BPY_PROPDEF_FLOAT_PREC_DOC \
2032   "   :arg precision: Maximum number of decimal digits to display, in [0, 6].\n" \
2033   "   :type precision: int\n"
2034
2035 #define BPY_PROPDEF_UPDATE_DOC \
2036   "   :arg update: Function to be called when this value is modified,\n" \
2037   "      This function must take 2 values (self, context) and return None.\n" \
2038   "      *Warning* there are no safety checks to avoid infinite recursion.\n" \
2039   "   :type update: function\n"
2040
2041 #define BPY_PROPDEF_POLL_DOC \
2042   "   :arg poll: function to be called to determine whether an item is valid for this " \
2043   "property.\n" \
2044   "              The function must take 2 values (self, object) and return Bool.\n" \
2045   "   :type poll: function\n"
2046
2047 #define BPY_PROPDEF_GET_DOC \
2048   "   :arg get: Function to be called when this value is 'read',\n" \
2049   "      This function must take 1 value (self) and return the value of the property.\n" \
2050   "   :type get: function\n"
2051
2052 #define BPY_PROPDEF_SET_DOC \
2053   "   :arg set: Function to be called when this value is 'written',\n" \
2054   "      This function must take 2 values (self, value) and return None.\n" \
2055   "   :type set: function\n"
2056
2057 #define BPY_PROPDEF_TYPE_DOC \
2058   "   :arg type: A subclass of :class:`bpy.types.PropertyGroup` or :class:`bpy.types.ID`.\n" \
2059   "   :type type: class\n"
2060
2061 #define BPY_PROPDEF_TAGS_DOC \
2062   "   :arg tags: Enumerator of tags that are defined by parent class.\n" \
2063   "   :type tags: set\n"
2064
2065 #if 0
2066 static int bpy_struct_id_used(StructRNA *srna, char *identifier)
2067 {
2068   PointerRNA ptr;
2069   RNA_pointer_create(NULL, srna, NULL, &ptr);
2070   return (RNA_struct_find_property(&ptr, identifier) != NULL);
2071 }
2072 #endif
2073
2074 /* Function that sets RNA, NOTE - self is NULL when called from python,
2075  * but being abused from C so we can pass the srna along.
2076  * This isn't incorrect since its a python object - but be careful */
2077 PyDoc_STRVAR(BPy_BoolProperty_doc,
2078              ".. function:: BoolProperty(name=\"\", "
2079              "description=\"\", "
2080              "default=False, "
2081              "options={'ANIMATABLE'}, "
2082              "tags={}, "
2083              "subtype='NONE', "
2084              "update=None, "
2085              "get=None, "
2086              "set=None)\n"
2087              "\n"
2088              "   Returns a new boolean property definition.\n"
2089              "\n" BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC BPY_PROPDEF_OPTIONS_DOC
2090                  BPY_PROPDEF_TAGS_DOC BPY_PROPDEF_SUBTYPE_NUMBER_DOC BPY_PROPDEF_UPDATE_DOC
2091                      BPY_PROPDEF_GET_DOC BPY_PROPDEF_SET_DOC);
2092 static PyObject *BPy_BoolProperty(PyObject *self, PyObject *args, PyObject *kw)
2093 {
2094   StructRNA *srna;
2095
2096   BPY_PROPDEF_HEAD(BoolProperty);
2097
2098   if (srna) {
2099     const char *id = NULL, *name = NULL, *description = "";
2100     int id_len;
2101     bool def = false;
2102     PropertyRNA *prop;
2103     PyObject *pyopts = NULL;
2104     int opts = 0;
2105     int prop_tags = 0;
2106     const char *pysubtype = NULL;
2107     int subtype = PROP_NONE;
2108     PyObject *update_cb = NULL;
2109     PyObject *get_cb = NULL;
2110     PyObject *set_cb = NULL;
2111     PyObject *py_tags = NULL;
2112
2113     static const char *_keywords[] = {
2114         "attr",
2115         "name",
2116         "description",
2117         "default",
2118         "options",
2119         "tags",
2120         "subtype",
2121         "update",
2122         "get",
2123         "set",
2124         NULL,
2125     };
2126     static _PyArg_Parser _parser = {"s#|ssO&O!O!sOOO:BoolProperty", _keywords, 0};
2127     if (!_PyArg_ParseTupleAndKeywordsFast(args,
2128                                           kw,
2129                                           &_parser,
2130                                           &id,
2131                                           &id_len,
2132                                           &name,
2133                                           &description,
2134                                           PyC_ParseBool,
2135                                           &def,
2136                                           &PySet_Type,
2137                                           &pyopts,
2138                                           &PySet_Type,
2139                                           &py_tags,
2140                                           &pysubtype,
2141                                           &update_cb,
2142                                           &get_cb,
2143                                           &set_cb)) {
2144       return NULL;
2145     }
2146
2147     BPY_PROPDEF_SUBTYPE_CHECK(BoolProperty, property_flag_items, property_subtype_number_items);
2148
2149     if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
2150       return NULL;
2151     }
2152     if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
2153       return NULL;
2154     }
2155     if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
2156       return NULL;
2157     }
2158
2159     prop = RNA_def_property(srna, id, PROP_BOOLEAN, subtype);
2160     RNA_def_property_boolean_default(prop, def);
2161     RNA_def_property_ui_text(prop, name ? name : id, description);
2162
2163     if (py_tags) {
2164       RNA_def_property_tags(prop, prop_tags);
2165     }
2166     if (pyopts) {
2167       bpy_prop_assign_flag(prop, opts);
2168     }
2169     bpy_prop_callback_assign_update(prop, update_cb);
2170     bpy_prop_callback_assign_boolean(prop, get_cb, set_cb);
2171     RNA_def_property_duplicate_pointers(srna, prop);
2172   }
2173
2174   Py_RETURN_NONE;
2175 }
2176
2177 PyDoc_STRVAR(BPy_BoolVectorProperty_doc,
2178              ".. function:: BoolVectorProperty(name=\"\", "
2179              "description=\"\", "
2180              "default=(False, False, False), "
2181              "options={'ANIMATABLE'}, "
2182              "tags={}, "
2183              "subtype='NONE', "
2184              "size=3, "
2185              "update=None, "
2186              "get=None, "
2187              "set=None)\n"
2188              "\n"
2189              "   Returns a new vector boolean property definition.\n"
2190              "\n" BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC
2191              "   :arg default: sequence of booleans the length of *size*.\n"
2192              "   :type default: sequence\n" BPY_PROPDEF_OPTIONS_DOC BPY_PROPDEF_TAGS_DOC
2193                  BPY_PROPDEF_SUBTYPE_ARRAY_DOC BPY_PROPDEF_VECSIZE_DOC BPY_PROPDEF_UPDATE_DOC
2194                      BPY_PROPDEF_GET_DOC BPY_PROPDEF_SET_DOC);
2195 static PyObject *BPy_BoolVectorProperty(PyObject *self, PyObject *args, PyObject *kw)
2196 {
2197   StructRNA *srna;
2198
2199   BPY_PROPDEF_HEAD(BoolVectorProperty);
2200
2201   if (srna) {
2202     const char *id = NULL, *name = NULL, *description = "";
2203     int id_len;
2204     bool def[PYRNA_STACK_ARRAY] = {0};
2205     int size = 3;
2206     PropertyRNA *prop;
2207     PyObject *pydef = NULL;
2208     PyObject *pyopts = NULL;
2209     int opts = 0;
2210     int prop_tags = 0;
2211     const char *pysubtype = NULL;
2212     int subtype = PROP_NONE;
2213     PyObject *update_cb = NULL;
2214     PyObject *get_cb = NULL;
2215     PyObject *set_cb = NULL;
2216     PyObject *py_tags = NULL;
2217
2218     static const char *_keywords[] = {
2219         "attr",
2220         "name",
2221         "description",
2222         "default",
2223         "options",
2224         "tags",
2225         "subtype",
2226         "size",
2227         "update",
2228         "get",
2229         "set",
2230         NULL,
2231     };
2232     static _PyArg_Parser _parser = {"s#|ssOO!O!siOOO:BoolVectorProperty", _keywords, 0};
2233     if (!_PyArg_ParseTupleAndKeywordsFast(args,
2234                                           kw,
2235                                           &_parser,
2236                                           &id,
2237                                           &id_len,
2238                                           &name,
2239                                           &description,
2240                                           &pydef,
2241                                           &PySet_Type,
2242                                           &pyopts,
2243                                           &PySet_Type,
2244                                           &py_tags,
2245                                           &pysubtype,
2246                                           &size,
2247                                           &update_cb,
2248                                           &get_cb,
2249                                           &set_cb)) {
2250       return NULL;
2251     }
2252
2253     BPY_PROPDEF_SUBTYPE_CHECK(
2254         BoolVectorProperty, property_flag_items, property_subtype_array_items);
2255
2256     if (size < 1 || size > PYRNA_STACK_ARRAY) {
2257       PyErr_Format(
2258           PyExc_TypeError,
2259           "BoolVectorProperty(size=%d): size must be between 0 and " STRINGIFY(PYRNA_STACK_ARRAY),
2260           size);
2261       return NULL;
2262     }
2263
2264     if (pydef &&
2265         PyC_AsArray(
2266             def, pydef, size, &PyBool_Type, false, "BoolVectorProperty(default=sequence)") == -1) {
2267       return NULL;
2268     }
2269
2270     if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
2271       return NULL;
2272     }
2273     if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
2274       return NULL;
2275     }
2276     if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
2277       return NULL;
2278     }
2279
2280 #if 0
2281     prop = RNA_def_boolean_array(
2282         srna, id, size, pydef ? def : NULL, name ? name : id, description);
2283 #endif
2284     prop = RNA_def_property(srna, id, PROP_BOOLEAN, subtype);
2285     RNA_def_property_array(prop, size);
2286     if (pydef) {
2287       RNA_def_property_boolean_array_default(prop, def);
2288     }
2289     RNA_def_property_ui_text(prop, name ? name : id, description);
2290
2291     if (py_tags) {
2292       RNA_def_property_tags(prop, prop_tags);
2293     }
2294     if (pyopts) {
2295       bpy_prop_assign_flag(prop, opts);
2296     }
2297     bpy_prop_callback_assign_update(prop, update_cb);
2298     bpy_prop_callback_assign_boolean_array(prop, get_cb, set_cb);
2299     RNA_def_property_duplicate_pointers(srna, prop);
2300   }
2301
2302   Py_RETURN_NONE;
2303 }
2304
2305 PyDoc_STRVAR(BPy_IntProperty_doc,
2306              ".. function:: IntProperty(name=\"\", "
2307              "description=\"\", "
2308              "default=0, "
2309              "min=-2**31, max=2**31-1, "
2310              "soft_min=-2**31, soft_max=2**31-1, "
2311              "step=1, "
2312              "options={'ANIMATABLE'}, "
2313              "tags={}, "
2314              "subtype='NONE', "
2315              "update=None, "
2316              "get=None, "
2317              "set=None)\n"
2318              "\n"
2319              "   Returns a new int property definition.\n"
2320              "\n" BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC BPY_PROPDEF_NUM_MIN_DOC
2321              "   :type min: int\n" BPY_PROPDEF_NUM_MAX_DOC
2322              "   :type max: int\n" BPY_PROPDEF_NUM_SOFTMAX_DOC
2323              "   :type soft_min: int\n" BPY_PROPDEF_NUM_SOFTMIN_DOC
2324              "   :type soft_max: int\n" BPY_PROPDEF_INT_STEP_DOC BPY_PROPDEF_OPTIONS_DOC
2325                  BPY_PROPDEF_TAGS_DOC BPY_PROPDEF_SUBTYPE_NUMBER_DOC BPY_PROPDEF_UPDATE_DOC
2326                      BPY_PROPDEF_GET_DOC BPY_PROPDEF_SET_DOC);
2327 static PyObject *BPy_IntProperty(PyObject *self, PyObject *args, PyObject *kw)
2328 {
2329   StructRNA *srna;
2330
2331   BPY_PROPDEF_HEAD(IntProperty);
2332
2333   if (srna) {
2334     const char *id = NULL, *name = NULL, *description = "";
2335     int id_len;
2336     int min = INT_MIN, max = INT_MAX, soft_min = INT_MIN, soft_max = INT_MAX, step = 1, def = 0;
2337     PropertyRNA *prop;
2338     PyObject *pyopts = NULL;
2339     int opts = 0;
2340     int prop_tags = 0;
2341     const char *pysubtype = NULL;
2342     int subtype = PROP_NONE;
2343     PyObject *update_cb = NULL;
2344     PyObject *get_cb = NULL;
2345     PyObject *set_cb = NULL;
2346     PyObject *py_tags = NULL;
2347
2348     static const char *_keywords[] = {
2349         "attr",
2350         "name",
2351         "description",
2352         "default",
2353         "min",
2354         "max",
2355         "soft_min",
2356         "soft_max",
2357         "step",
2358         "options",
2359         "tags",
2360         "subtype",
2361         "update",
2362         "get",
2363         "set",
2364         NULL,
2365     };
2366     static _PyArg_Parser _parser = {"s#|ssiiiiiiO!O!sOOO:IntProperty", _keywords, 0};
2367     if (!_PyArg_ParseTupleAndKeywordsFast(args,
2368                                           kw,
2369                                           &_parser,
2370                                           &id,
2371                                           &id_len,
2372                                           &name,
2373                                           &description,
2374                                           &def,
2375                                           &min,
2376                                           &max,
2377                                           &soft_min,
2378                                           &soft_max,
2379                                           &step,
2380                                           &PySet_Type,
2381                                           &pyopts,
2382                                           &PySet_Type,
2383                                           &py_tags,
2384                                           &pysubtype,
2385                                           &update_cb,
2386                                           &get_cb,
2387                                           &set_cb)) {
2388       return NULL;
2389     }
2390
2391     BPY_PROPDEF_SUBTYPE_CHECK(IntProperty, property_flag_items, property_subtype_number_items);
2392
2393     if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
2394       return NULL;
2395     }
2396     if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
2397       return NULL;
2398     }
2399     if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
2400       return NULL;
2401     }
2402
2403     prop = RNA_def_property(srna, id, PROP_INT, subtype);
2404     RNA_def_property_int_default(prop, def);
2405     RNA_def_property_ui_text(prop, name ? name : id, description);
2406     RNA_def_property_range(prop, min, max);
2407     RNA_def_property_ui_range(prop, MAX2(soft_min, min), MIN2(soft_max, max), step, 3);
2408
2409     if (py_tags) {
2410       RNA_def_property_tags(prop, prop_tags);
2411     }
2412     if (pyopts) {
2413       bpy_prop_assign_flag(prop, opts);
2414     }
2415     bpy_prop_callback_assign_update(prop, update_cb);
2416     bpy_prop_callback_assign_int(prop, get_cb, set_cb);
2417     RNA_def_property_duplicate_pointers(srna, prop);
2418   }
2419   Py_RETURN_NONE;
2420 }
2421
2422 PyDoc_STRVAR(BPy_IntVectorProperty_doc,
2423              ".. function:: IntVectorProperty(name=\"\", "
2424              "description=\"\", "
2425              "default=(0, 0, 0), min=-2**31, max=2**31-1, "
2426              "soft_min=-2**31, "
2427              "soft_max=2**31-1, "
2428              "step=1, "
2429              "options={'ANIMATABLE'}, "
2430              "tags={}, "
2431              "subtype='NONE', "
2432              "size=3, "
2433              "update=None, "
2434              "get=None, "
2435              "set=None)\n"
2436              "\n"
2437              "   Returns a new vector int property definition.\n"
2438              "\n" BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC
2439              "   :arg default: sequence of ints the length of *size*.\n"
2440              "   :type default: sequence\n" BPY_PROPDEF_NUM_MIN_DOC
2441              "   :type min: int\n" BPY_PROPDEF_NUM_MAX_DOC
2442              "   :type max: int\n" BPY_PROPDEF_NUM_SOFTMIN_DOC
2443              "   :type soft_min: int\n" BPY_PROPDEF_NUM_SOFTMAX_DOC
2444              "   :type soft_max: int\n" BPY_PROPDEF_INT_STEP_DOC BPY_PROPDEF_OPTIONS_DOC
2445                  BPY_PROPDEF_TAGS_DOC BPY_PROPDEF_SUBTYPE_ARRAY_DOC BPY_PROPDEF_VECSIZE_DOC
2446                      BPY_PROPDEF_UPDATE_DOC BPY_PROPDEF_GET_DOC BPY_PROPDEF_SET_DOC);
2447 static PyObject *BPy_IntVectorProperty(PyObject *self, PyObject *args, PyObject *kw)
2448 {
2449   StructRNA *srna;
2450
2451   BPY_PROPDEF_HEAD(IntVectorProperty);
2452
2453   if (srna) {
2454     const char *id = NULL, *name = NULL, *description = "";
2455     int id_len;
2456     int min = INT_MIN, max = INT_MAX, soft_min = INT_MIN, soft_max = INT_MAX, step = 1;
2457     int def[PYRNA_STACK_ARRAY] = {0};
2458     int size = 3;
2459     PropertyRNA *prop;
2460     PyObject *pydef = NULL;
2461     PyObject *pyopts = NULL;
2462     int opts = 0;
2463     int prop_tags = 0;
2464     const char *pysubtype = NULL;
2465     int subtype = PROP_NONE;
2466     PyObject *update_cb = NULL;
2467     PyObject *get_cb = NULL;
2468     PyObject *set_cb = NULL;
2469     PyObject *py_tags = NULL;
2470
2471     static const char *_keywords[] = {
2472         "attr",
2473         "name",
2474         "description",
2475         "default",
2476         "min",
2477         "max",
2478         "soft_min",
2479         "soft_max",
2480         "step",
2481         "options",
2482         "tags",
2483         "subtype",
2484         "size",
2485         "update",
2486         "get",
2487         "set",
2488         NULL,
2489     };
2490     static _PyArg_Parser _parser = {"s#|ssOiiiiiO!O!siOOO:IntVectorProperty", _keywords, 0};
2491     if (!_PyArg_ParseTupleAndKeywordsFast(args,
2492                                           kw,
2493                                           &_parser,
2494                                           &id,
2495                                           &id_len,
2496                                           &name,
2497                                           &description,
2498                                           &pydef,
2499                                           &min,
2500                                           &max,
2501                                           &soft_min,
2502                                           &soft_max,
2503                                           &step,
2504                                           &PySet_Type,
2505                                           &pyopts,
2506                                           &PySet_Type,
2507                                           &py_tags,
2508                                           &pysubtype,
2509                                           &size,
2510                                           &update_cb,
2511                                           &get_cb,
2512                                           &set_cb)) {
2513       return NULL;
2514     }
2515
2516     BPY_PROPDEF_SUBTYPE_CHECK(
2517         IntVectorProperty, property_flag_items, property_subtype_array_items);
2518
2519     if (size < 1 || size > PYRNA_STACK_ARRAY) {
2520       PyErr_Format(
2521           PyExc_TypeError,
2522           "IntVectorProperty(size=%d): size must be between 0 and " STRINGIFY(PYRNA_STACK_ARRAY),
2523           size);
2524       return NULL;
2525     }
2526
2527     if (pydef &&
2528         PyC_AsArray(
2529             def, pydef, size, &PyLong_Type, false, "IntVectorProperty(default=sequence)") == -1) {
2530       return NULL;
2531     }
2532
2533     if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
2534       return NULL;
2535     }
2536     if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
2537       return NULL;
2538     }
2539     if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
2540       return NULL;
2541     }
2542
2543     prop = RNA_def_property(srna, id, PROP_INT, subtype);
2544     RNA_def_property_array(prop, size);
2545     if (pydef) {
2546       RNA_def_property_int_array_default(prop, def);
2547     }
2548     RNA_def_property_range(prop, min, max);
2549     RNA_def_property_ui_text(prop, name ? name : id, description);
2550     RNA_def_property_ui_range(prop, MAX2(soft_min, min), MIN2(soft_max, max), step, 3);
2551
2552     if (py_tags) {
2553       RNA_def_property_tags(prop, prop_tags);
2554     }
2555     if (pyopts) {
2556       bpy_prop_assign_flag(prop, opts);
2557     }
2558     bpy_prop_callback_assign_update(prop, update_cb);
2559     bpy_prop_callback_assign_int_array(prop, get_cb, set_cb);
2560     RNA_def_property_duplicate_pointers(srna, prop);
2561   }
2562   Py_RETURN_NONE;
2563 }
2564
2565 PyDoc_STRVAR(BPy_FloatProperty_doc,
2566              ".. function:: FloatProperty(name=\"\", "
2567              "description=\"\", "
2568              "default=0.0, "
2569              "min=-3.402823e+38, max=3.402823e+38, "
2570              "soft_min=-3.402823e+38, soft_max=3.402823e+38, "
2571              "step=3, "
2572              "precision=2, "
2573              "options={'ANIMATABLE'}, "
2574              "tags={}, "
2575              "subtype='NONE', "
2576              "unit='NONE', "
2577              "update=None, "
2578              "get=None, "
2579              "set=None)\n"
2580              "\n"
2581              "   Returns a new float (single precision) property definition.\n"
2582              "\n" BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC BPY_PROPDEF_NUM_MIN_DOC
2583              "   :type min: float\n" BPY_PROPDEF_NUM_MAX_DOC
2584              "   :type max: float\n" BPY_PROPDEF_NUM_SOFTMIN_DOC
2585              "   :type soft_min: float\n" BPY_PROPDEF_NUM_SOFTMAX_DOC
2586              "   :type soft_max: float\n" BPY_PROPDEF_FLOAT_STEP_DOC BPY_PROPDEF_FLOAT_PREC_DOC
2587                  BPY_PROPDEF_OPTIONS_DOC BPY_PROPDEF_TAGS_DOC BPY_PROPDEF_SUBTYPE_NUMBER_DOC
2588                      BPY_PROPDEF_UNIT_DOC BPY_PROPDEF_UPDATE_DOC BPY_PROPDEF_GET_DOC
2589                          BPY_PROPDEF_SET_DOC);
2590 static PyObject *BPy_FloatProperty(PyObject *self, PyObject *args, PyObject *kw)
2591 {
2592   StructRNA *srna;
2593
2594   BPY_PROPDEF_HEAD(FloatProperty);
2595
2596   if (srna) {
2597     const char *id = NULL, *name = NULL, *description = "";
2598     int id_len;
2599     float min = -FLT_MAX, max = FLT_MAX, soft_min = -FLT_MAX, soft_max = FLT_MAX, step = 3,
2600           def = 0.0f;
2601     int precision = 2;
2602     PropertyRNA *prop;
2603     PyObject *pyopts = NULL;
2604     int opts = 0;
2605     int prop_tags = 0;
2606     const char *pysubtype = NULL;
2607     int subtype = PROP_NONE;
2608     const char *pyunit = NULL;
2609     int unit = PROP_UNIT_NONE;
2610     PyObject *update_cb = NULL;
2611     PyObject *get_cb = NULL;
2612     PyObject *set_cb = NULL;
2613     PyObject *py_tags = NULL;
2614
2615     static const char *_keywords[] = {
2616         "attr",
2617         "name",
2618         "description",
2619         "default",
2620         "min",
2621         "max",
2622         "soft_min",
2623         "soft_max",
2624         "step",
2625         "precision",
2626         "options",
2627         "tags",
2628         "subtype",
2629         "unit",
2630         "update",
2631         "get",
2632         "set",
2633         NULL,
2634     };
2635     static _PyArg_Parser _parser = {"s#|ssffffffiO!O!ssOOO:FloatProperty", _keywords, 0};
2636     if (!_PyArg_ParseTupleAndKeywordsFast(args,
2637                                           kw,
2638                                           &_parser,
2639                                           &id,
2640                                           &id_len,
2641                                           &name,
2642                                           &description,
2643                                           &def,
2644                                           &min,
2645                                           &max,
2646                                           &soft_min,
2647                                           &soft_max,
2648                                           &step,
2649                                           &precision,
2650                                           &PySet_Type,
2651                                           &pyopts,
2652                                           &PySet_Type,
2653                                           &py_tags,
2654                                           &pysubtype,
2655                                           &pyunit,
2656                                           &update_cb,
2657                                           &get_cb,
2658                                           &set_cb)) {
2659       return NULL;
2660     }
2661
2662     BPY_PROPDEF_SUBTYPE_CHECK(FloatProperty, property_flag_items, property_subtype_number_items);
2663
2664     if (pyunit && RNA_enum_value_from_id(rna_enum_property_unit_items, pyunit, &unit) == 0) {
2665       PyErr_Format(PyExc_TypeError, "FloatProperty(unit='%s'): invalid unit", pyunit);
2666       return NULL;
2667     }
2668
2669     if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
2670       return NULL;
2671     }
2672     if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
2673       return NULL;
2674     }
2675     if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
2676       return NULL;
2677     }
2678
2679     prop = RNA_def_property(srna, id, PROP_FLOAT, subtype | unit);
2680     RNA_def_property_float_default(prop, def);
2681     RNA_def_property_range(prop, min, max);
2682     RNA_def_property_ui_text(prop, name ? name : id, description);
2683     RNA_def_property_ui_range(prop, MAX2(soft_min, min), MIN2(soft_max, max), step, precision);
2684
2685     if (py_tags) {
2686       RNA_def_property_tags(prop, prop_tags);
2687     }
2688     if (pyopts) {
2689       bpy_prop_assign_flag(prop, opts);
2690     }
2691     bpy_prop_callback_assign_update(prop, update_cb);
2692     bpy_prop_callback_assign_float(prop, get_cb, set_cb);
2693     RNA_def_property_duplicate_pointers(srna, prop);
2694   }
2695   Py_RETURN_NONE;
2696 }
2697
2698 PyDoc_STRVAR(BPy_FloatVectorProperty_doc,
2699              ".. function:: FloatVectorProperty(name=\"\", "
2700              "description=\"\", "
2701              "default=(0.0, 0.0, 0.0), "
2702              "min=sys.float_info.min, max=sys.float_info.max, "
2703              "soft_min=sys.float_info.min, soft_max=sys.float_info.max, "
2704              "step=3, "
2705              "precision=2, "
2706              "options={'ANIMATABLE'}, "
2707              "tags={}, "
2708              "subtype='NONE', "
2709              "unit='NONE', "
2710              "size=3, "
2711              "update=None, "
2712              "get=None, "
2713              "set=None)\n"
2714              "\n"
2715              "   Returns a new vector float property definition.\n"
2716              "\n" BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC
2717              "   :arg default: sequence of floats the length of *size*.\n"
2718              "   :type default: sequence\n" BPY_PROPDEF_NUM_MIN_DOC
2719              "   :type min: float\n" BPY_PROPDEF_NUM_MAX_DOC
2720              "   :type max: float\n" BPY_PROPDEF_NUM_SOFTMIN_DOC
2721              "   :type soft_min: float\n" BPY_PROPDEF_NUM_SOFTMAX_DOC
2722              "   :type soft_max: float\n" BPY_PROPDEF_OPTIONS_DOC BPY_PROPDEF_TAGS_DOC
2723                  BPY_PROPDEF_FLOAT_STEP_DOC BPY_PROPDEF_FLOAT_PREC_DOC
2724                      BPY_PROPDEF_SUBTYPE_ARRAY_DOC BPY_PROPDEF_UNIT_DOC BPY_PROPDEF_VECSIZE_DOC
2725                          BPY_PROPDEF_UPDATE_DOC BPY_PROPDEF_GET_DOC BPY_PROPDEF_SET_DOC);
2726 static PyObject *BPy_FloatVectorProperty(PyObject *self, PyObject *args, PyObject *kw)
2727 {
2728   StructRNA *srna;
2729
2730   BPY_PROPDEF_HEAD(FloatVectorProperty);
2731
2732   if (srna) {
2733     const char *id = NULL, *name = NULL, *description = "";
2734     int id_len;
2735     float min = -FLT_MAX, max = FLT_MAX, soft_min = -FLT_MAX, soft_max = FLT_MAX, step = 3;
2736     float def[PYRNA_STACK_ARRAY] = {0.0f};
2737     int precision = 2, size = 3;
2738     PropertyRNA *prop;
2739     PyObject *pydef = NULL;
2740     PyObject *pyopts = NULL;
2741     int opts = 0;
2742     int prop_tags = 0;
2743     const char *pysubtype = NULL;
2744     int subtype = PROP_NONE;
2745     const char *pyunit = NULL;
2746     int unit = PROP_UNIT_NONE;
2747     PyObject *update_cb = NULL;
2748     PyObject *get_cb = NULL;
2749     PyObject *set_cb = NULL;
2750     PyObject *py_tags = NULL;
2751
2752     static const char *_keywords[] = {
2753         "attr",     "name",   "description", "default", "min",  "max",     "soft_min",
2754         "soft_max", "step",   "precision",   "options", "tags", "subtype", "unit",
2755         "size",     "update", "get",         "set",     NULL,
2756     };
2757     static _PyArg_Parser _parser = {"s#|ssOfffffiO!O!ssiOOO:FloatVectorProperty", _keywords, 0};
2758     if (!_PyArg_ParseTupleAndKeywordsFast(args,
2759                                           kw,
2760                                           &_parser,
2761                                           &id,
2762                                           &id_len,
2763                                           &name,
2764                                           &description,
2765                                           &pydef,
2766                                           &min,
2767                                           &max,
2768                                           &soft_min,
2769                                           &soft_max,
2770                                           &step,
2771                                           &precision,
2772                                           &PySet_Type,
2773                                           &pyopts,
2774                                           &PySet_Type,
2775                                           &py_tags,
2776                                           &pysubtype,
2777                                           &pyunit,
2778                                           &size,
2779                                           &update_cb,
2780                                           &get_cb,
2781                                           &set_cb)) {
2782       return NULL;
2783     }
2784
2785     BPY_PROPDEF_SUBTYPE_CHECK(
2786         FloatVectorProperty, property_flag_items, property_subtype_array_items);
2787
2788     if (pyunit && RNA_enum_value_from_id(rna_enum_property_unit_items, pyunit, &unit) == 0) {
2789       PyErr_Format(PyExc_TypeError, "FloatVectorProperty(unit='%s'): invalid unit", pyunit);
2790       return NULL;
2791     }
2792
2793     if (size < 1 || size > PYRNA_STACK_ARRAY) {
2794       PyErr_Format(
2795           PyExc_TypeError,
2796           "FloatVectorProperty(size=%d): size must be between 0 and " STRINGIFY(PYRNA_STACK_ARRAY),
2797           size);
2798       return NULL;
2799     }
2800
2801     if (pydef &&
2802         PyC_AsArray(
2803             def, pydef, size, &PyFloat_Type, false, "FloatVectorProperty(default=sequence)") ==
2804             -1) {
2805       return NULL;
2806     }
2807
2808     if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
2809       return NULL;
2810     }
2811     if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
2812       return NULL;
2813     }
2814     if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
2815       return NULL;
2816     }
2817
2818     prop = RNA_def_property(srna, id, PROP_FLOAT, subtype | unit);
2819     RNA_def_property_array(prop, size);
2820     if (pydef) {
2821       RNA_def_property_float_array_default(prop, def);
2822     }
2823     RNA_def_property_range(prop, min, max);
2824     RNA_def_property_ui_text(prop, name ? name : id, description);
2825     RNA_def_property_ui_range(prop, MAX2(soft_min, min), MIN2(soft_max, max), step, precision);
2826
2827     if (py_tags) {
2828       RNA_def_property_tags(prop, prop_tags);
2829     }
2830     if (pyopts) {
2831       bpy_prop_assign_flag(prop, opts);
2832     }
2833     bpy_prop_callback_assign_update(prop, update_cb);
2834     bpy_prop_callback_assign_float_array(prop, get_cb, set_cb);
2835     RNA_def_property_duplicate_pointers(srna, prop);
2836   }
2837   Py_RETURN_NONE;
2838 }
2839
2840 PyDoc_STRVAR(BPy_StringProperty_doc,
2841              ".. function:: StringProperty(name=\"\", "
2842              "description=\"\", "
2843              "default=\"\", "
2844              "maxlen=0, "
2845              "options={'ANIMATABLE'}, "
2846              "tags={}, "
2847              "subtype='NONE', "
2848              "update=None, "
2849              "get=None, "
2850              "set=None)\n"
2851              "\n"
2852              "   Returns a new string property definition.\n"
2853              "\n" BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC
2854              "   :arg default: initializer string.\n"
2855              "   :type default: string\n"
2856              "   :arg maxlen: maximum length of the string.\n"
2857              "   :type maxlen: int\n" BPY_PROPDEF_OPTIONS_DOC BPY_PROPDEF_TAGS_DOC
2858                  BPY_PROPDEF_SUBTYPE_STRING_DOC BPY_PROPDEF_UPDATE_DOC BPY_PROPDEF_GET_DOC
2859                      BPY_PROPDEF_SET_DOC);
2860 static PyObject *BPy_StringProperty(PyObject *self, PyObject *args, PyObject *kw)
2861 {
2862   StructRNA *srna;
2863
2864   BPY_PROPDEF_HEAD(StringProperty);
2865
2866   if (srna) {
2867     const char *id = NULL, *name = NULL, *description = "", *def = "";
2868     int id_len;
2869     int maxlen = 0;
2870     PropertyRNA *prop;
2871     PyObject *pyopts = NULL;
2872     int opts = 0;
2873     int prop_tags = 0;
2874     const char *pysubtype = NULL;
2875     int subtype = PROP_NONE;
2876     PyObject *update_cb = NULL;
2877     PyObject *get_cb = NULL;
2878     PyObject *set_cb = NULL;
2879     PyObject *py_tags = NULL;
2880
2881     static const char *_keywords[] = {
2882         "attr",
2883         "name",
2884         "description",
2885         "default",
2886         "maxlen",
2887         "options",
2888         "tags",
2889         "subtype",
2890         "update",
2891         "get",
2892         "set",
2893         NULL,
2894     };
2895     static _PyArg_Parser _parser = {"s#|sssiO!O!sOOO:StringProperty", _keywords, 0};
2896     if (!_PyArg_ParseTupleAndKeywordsFast(args,
2897                                           kw,
2898                                           &_parser,
2899                                           &id,
2900                                           &id_len,
2901                                           &name,
2902                                           &description,
2903                                           &def,
2904                                           &maxlen,
2905                                           &PySet_Type,
2906                                           &pyopts,
2907                                           &PySet_Type,
2908                                           &py_tags,
2909                                           &pysubtype,
2910                                           &update_cb,
2911                                           &get_cb,
2912                                           &set_cb)) {
2913       return NULL;
2914     }
2915
2916     BPY_PROPDEF_SUBTYPE_CHECK(StringProperty, property_flag_items, property_subtype_string_items);
2917
2918     if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
2919       return NULL;
2920     }
2921     if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
2922       return NULL;
2923     }
2924     if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
2925       return NULL;
2926     }
2927
2928     prop = RNA_def_property(srna, id, PROP_STRING, subtype);
2929     if (maxlen != 0) {
2930       RNA_def_property_string_maxlength(prop,
2931                                         maxlen + 1); /* +1 since it includes null terminator */
2932     }
2933     if (def && def[0]) {
2934       RNA_def_property_string_default(prop, def);
2935     }
2936     RNA_def_property_ui_text(prop, name ? name : id, description);
2937
2938     if (py_tags) {
2939       RNA_def_property_tags(prop, prop_tags);
2940     }
2941     if (pyopts) {
2942       bpy_prop_assign_flag(prop, opts);
2943     }
2944     bpy_prop_callback_assign_update(prop, update_cb);
2945     bpy_prop_callback_assign_string(prop, get_cb, set_cb);
2946     RNA_def_property_duplicate_pointers(srna, prop);
2947   }
2948   Py_RETURN_NONE;
2949 }
2950
2951 PyDoc_STRVAR(
2952     BPy_EnumProperty_doc,
2953     ".. function:: EnumProperty(items, "
2954     "name=\"\", "
2955     "description=\"\", "
2956     "default=None, "
2957     "options={'ANIMATABLE'}, "
2958     "tags={}, "
2959     "update=None, "
2960     "get=None, "
2961     "set=None)\n"
2962     "\n"
2963     "   Returns a new enumerator property definition.\n"
2964     "\n"
2965     "   :arg items: sequence of enum items formatted:\n"
2966     "      ``[(identifier, name, description, icon, number), ...]``.\n"
2967     "\n"
2968     "      The first three elements of the tuples are mandatory.\n"
2969     "\n"
2970     "      :identifier: The identifier is used for Python access.\n"
2971     "      :name: Name for the interface.\n"
2972     "      :description: Used for documentation and tooltips.\n"
2973     "      :icon: An icon string identifier or integer icon value\n"
2974     "         (e.g. returned by :class:`bpy.types.UILayout.icon`)\n"
2975     "      :number: Unique value used as the identifier for this item (stored in file data).\n"
2976     "         Use when the identifier may need to change. If the *ENUM_FLAG* option is used,\n"
2977     "         the values are bitmasks and should be powers of two.\n"
2978     "\n"
2979     "      When an item only contains 4 items they define ``(identifier, name, description, "
2980     "number)``.\n"
2981     "\n"
2982     "      For dynamic values a callback can be passed which returns a list in\n"
2983     "      the same format as the static list.\n"
2984     "      This function must take 2 arguments ``(self, context)``, **context may be None**.\n"
2985     "\n"
2986     "      .. warning::\n"
2987     "\n"
2988     "         There is a known bug with using a callback,\n"
2989     "         Python must keep a reference to the strings returned by the callback or Blender\n"
2990     "         will misbehave or even crash."
2991     "\n"
2992     "   :type items: sequence of string tuples or a function\n" BPY_PROPDEF_NAME_DOC
2993         BPY_PROPDEF_DESC_DOC
2994     "   :arg default: The default value for this enum, a string from the identifiers used in "
2995     "*items*.\n"
2996     "      If the *ENUM_FLAG* option is used this must be a set of such string identifiers "
2997     "instead.\n"
2998     "      WARNING: It shall not be specified (or specified to its default *None* value) for "
2999     "dynamic enums\n"
3000     "      (i.e. if a callback function is given as *items* parameter).\n"
3001     "   :type default: string or set\n" BPY_PROPDEF_OPTIONS_ENUM_DOC BPY_PROPDEF_TAGS_DOC
3002         BPY_PROPDEF_UPDATE_DOC BPY_PROPDEF_GET_DOC BPY_PROPDEF_SET_DOC);
3003 static PyObject *BPy_EnumProperty(PyObject *self, PyObject *args, PyObject *kw)
3004 {
3005   StructRNA *srna;
3006
3007   BPY_PROPDEF_HEAD(EnumProperty);
3008
3009   if (srna) {
3010     const char *id = NULL, *name = NULL, *description = "";
3011     PyObject *def = NULL;
3012     int id_len;
3013     int defvalue = 0;
3014     PyObject *items, *items_fast;
3015     const EnumPropertyItem *eitems;
3016     PropertyRNA *prop;
3017     PyObject *pyopts = NULL;
3018     int opts = 0;
3019     int prop_tags = 0;
3020     bool is_itemf = false;
3021     PyObject *update_cb = NULL;
3022     PyObject *get_cb = NULL;
3023     PyObject *set_cb = NULL;
3024     PyObject *py_tags = NULL;
3025
3026     static const char *_keywords[] = {
3027         "attr",
3028         "items",
3029         "name",
3030         "description",
3031         "default",
3032         "options",
3033         "tags",
3034         "update",
3035         "get",
3036         "set",
3037         NULL,
3038     };
3039     static _PyArg_Parser _parser = {"s#O|ssOO!O!OOO:EnumProperty", _keywords, 0};
3040     if (!_PyArg_ParseTupleAndKeywordsFast(args,
3041                                           kw,
3042                                           &_parser,
3043                                           &id,
3044                                           &id_len,
3045                                           &items,
3046                                           &name,
3047                                           &description,
3048                                           &def,
3049                                           &PySet_Type,
3050                                           &pyopts,
3051                                           &PySet_Type,
3052                                           &py_tags,
3053                                           &update_cb,
3054                                           &get_cb,
3055                                           &set_cb)) {
3056       return NULL;
3057     }
3058
3059     BPY_PROPDEF_CHECK(EnumProperty, property_flag_enum_items);
3060
3061     if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
3062       return NULL;
3063     }
3064     if (bpy_prop_callback_check(get_cb, "get", 1) == -1) {
3065       return NULL;
3066     }
3067     if (bpy_prop_callback_check(set_cb, "set", 2) == -1) {
3068       return NULL;
3069     }
3070
3071     if (def == Py_None) {
3072       /* This allows to get same behavior when explicitly passing None as default value,
3073        * and not defining a default value at all! */
3074       def = NULL;
3075     }
3076
3077     /* items can be a list or a callable */
3078     if (PyFunction_Check(
3079             items)) { /* don't use PyCallable_Check because we need the function code for errors */
3080       PyCodeObject *f_code = (PyCodeObject *)PyFunction_GET_CODE(items);
3081       if (f_code->co_argcount != 2) {
3082         PyErr_Format(PyExc_ValueError,
3083                      "EnumProperty(...): expected 'items' function to take 2 arguments, not %d",
3084                      f_code->co_argcount);
3085         return NULL;
3086       }
3087
3088       if (def) {
3089         /* note, using type error here is odd but python does this for invalid arguments */
3090         PyErr_SetString(PyExc_TypeError,
3091                         "EnumProperty(...): 'default' can't be set when 'items' is a function");
3092         return NULL;
3093       }
3094
3095       is_itemf = true;
3096       eitems = DummyRNA_NULL_items;
3097     }
3098     else {
3099       if (!(items_fast = PySequence_Fast(
3100                 items,
3101                 "EnumProperty(...): "
3102                 "expected a sequence of tuples for the enum items or a function"))) {
3103         return NULL;
3104       }
3105
3106       eitems = enum_items_from_py(items_fast, def, &defvalue, (opts & PROP_ENUM_FLAG) != 0);
3107
3108       if (!eitems) {
3109         Py_DECREF(items_fast);
3110         return NULL;
3111       }
3112     }
3113
3114     if (opts & PROP_ENUM_FLAG) {
3115       prop = RNA_def_enum_flag(srna, id, eitems, defvalue, name ? name : id, description);
3116     }
3117     else {
3118       prop = RNA_def_enum(srna, id, eitems, defvalue, name ? name : id, description);
3119     }
3120
3121     if (py_tags) {
3122       RNA_def_property_tags(prop, prop_tags);
3123     }
3124     if (pyopts) {
3125       bpy_prop_assign_flag(prop, opts);
3126     }
3127     bpy_prop_callback_assign_update(prop, update_cb);
3128     bpy_prop_callback_assign_enum(prop, get_cb, set_cb, (is_itemf ? items : NULL));
3129     RNA_def_property_duplicate_pointers(srna, prop);
3130
3131     if (is_itemf == false) {
3132       /* note: this must be postponed until after #RNA_def_property_duplicate_pointers
3133        * otherwise if this is a generator it may free the strings before we copy them */
3134       Py_DECREF(items_fast);
3135
3136       MEM_freeN((void *)eitems);
3137     }
3138   }
3139   Py_RETURN_NONE;
3140 }
3141
3142 StructRNA *pointer_type_from_py(PyObject *value, const char *error_prefix)
3143 {
3144   StructRNA *srna;
3145
3146   srna = srna_from_self(value, "");
3147   if (!srna) {
3148     if (PyErr_Occurred()) {
3149       PyObject *msg = PyC_ExceptionBuffer();
3150       const char *msg_char = _PyUnicode_AsString(msg);
3151       PyErr_Format(
3152           PyExc_TypeError, "%.200s expected an RNA type, failed with: %s", error_prefix, msg_char);
3153       Py_DECREF(msg);
3154     }
3155     else {
3156       PyErr_Format(PyExc_TypeError,
3157                    "%.200s expected an RNA type, failed with type '%s'",
3158                    error_prefix,
3159                    Py_TYPE(value)->tp_name);
3160     }
3161     return NULL;
3162   }
3163
3164   return srna;
3165 }
3166
3167 PyDoc_STRVAR(BPy_PointerProperty_doc,
3168              ".. function:: PointerProperty(type=None, "
3169              "name=\"\", "
3170              "description=\"\", "
3171              "options={'ANIMATABLE'}, "
3172              "tags={}, "
3173              "poll=None, "
3174              "update=None)\n"
3175              "\n"
3176              "   Returns a new pointer property definition.\n"
3177              "\n" BPY_PROPDEF_TYPE_DOC BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC
3178                  BPY_PROPDEF_OPTIONS_DOC BPY_PROPDEF_TAGS_DOC BPY_PROPDEF_POLL_DOC
3179                      BPY_PROPDEF_UPDATE_DOC);
3180 PyObject *BPy_PointerProperty(PyObject *self, PyObject *args, PyObject *kw)
3181 {
3182   StructRNA *srna;
3183
3184   BPY_PROPDEF_HEAD(PointerProperty);
3185
3186   if (srna) {
3187     const char *id = NULL, *name = NULL, *description = "";
3188     int id_len;
3189     PropertyRNA *prop;
3190     StructRNA *ptype;
3191     PyObject *type = Py_None;
3192     PyObject *pyopts = NULL;
3193     PyObject *py_tags = NULL;
3194     int opts = 0;
3195     int prop_tags = 0;
3196     PyObject *update_cb = NULL, *poll_cb = NULL;
3197
3198     static const char *_keywords[] = {
3199         "attr",
3200         "type",
3201         "name",
3202         "description",
3203         "options",
3204         "tags",
3205         "poll",
3206         "update",
3207         NULL,
3208     };
3209     static _PyArg_Parser _parser = {"s#O|ssO!O!OO:PointerProperty", _keywords, 0};
3210     if (!_PyArg_ParseTupleAndKeywordsFast(args,
3211                                           kw,
3212                                           &_parser,
3213                                           &id,
3214                                           &id_len,
3215                                           &type,
3216                                           &name,
3217                                           &description,
3218                                           &PySet_Type,
3219                                           &pyopts,
3220                                           &PySet_Type,
3221                                           &py_tags,
3222                                           &poll_cb,
3223                                           &update_cb)) {
3224       return NULL;
3225     }
3226
3227     BPY_PROPDEF_CHECK(PointerProperty, property_flag_items);
3228
3229     ptype = pointer_type_from_py(type, "PointerProperty(...)");
3230     if (!ptype) {
3231       return NULL;
3232     }
3233     if (!RNA_struct_is_a(ptype, &RNA_PropertyGroup) && !RNA_struct_is_ID(ptype)) {
3234       PyErr_Format(PyExc_TypeError,
3235                    "PointerProperty(...) expected an RNA type derived from %.200s or %.200s",
3236                    RNA_struct_ui_name(&RNA_ID),
3237                    RNA_struct_ui_name(&RNA_PropertyGroup));
3238       return NULL;
3239     }
3240     if (bpy_prop_callback_check(update_cb, "update", 2) == -1) {
3241       return NULL;
3242     }
3243     if (bpy_prop_callback_check(poll_cb, "poll", 2) == -1) {
3244       return NULL;
3245     }
3246     prop = RNA_def_pointer_runtime(srna, id, ptype, name ? name : id, description);
3247     if (py_tags) {
3248       RNA_def_property_tags(prop, prop_tags);
3249     }
3250     if (pyopts) {
3251       bpy_prop_assign_flag(prop, opts);
3252     }
3253
3254     if (RNA_struct_idprops_contains_datablock(ptype)) {
3255       if (RNA_struct_is_a(srna, &RNA_PropertyGroup)) {
3256         RNA_def_struct_flag(srna, STRUCT_CONTAINS_DATABLOCK_IDPROPERTIES);
3257       }
3258     }
3259     bpy_prop_callback_assign_update(prop, update_cb);
3260     bpy_prop_callback_assign_pointer(prop, poll_cb);
3261     RNA_def_property_duplicate_pointers(srna, prop);
3262   }
3263   Py_RETURN_NONE;
3264 }
3265
3266 PyDoc_STRVAR(BPy_CollectionProperty_doc,
3267              ".. function:: CollectionProperty(type=None, "
3268              "name=\"\", "
3269              "description=\"\", "
3270              "options={'ANIMATABLE'}, "
3271              "tags={})\n"
3272              "\n"
3273              "   Returns a new collection property definition.\n"
3274              "\n" BPY_PROPDEF_TYPE_DOC BPY_PROPDEF_NAME_DOC BPY_PROPDEF_DESC_DOC
3275                  BPY_PROPDEF_OPTIONS_DOC BPY_PROPDEF_TAGS_DOC);
3276 PyObject *BPy_CollectionProperty(PyObject *self, PyObject *args, PyObject *kw)
3277 {
3278   StructRNA *srna;
3279
3280   BPY_PROPDEF_HEAD(CollectionProperty);
3281
3282   if (srna) {
3283     int id_len;
3284     const char *id = NULL, *name = NULL, *description = "";
3285     PropertyRNA *prop;
3286     StructRNA *ptype;
3287     PyObject *type = Py_None;
3288     PyObject *pyopts = NULL;
3289     PyObject *py_tags = NULL;
3290     int opts = 0;
3291     int prop_tags = 0;
3292
3293     static const char *_keywords[] = {
3294         "attr",
3295         "type",
3296         "name",
3297         "description",
3298         "options",
3299         "tags",
3300         NULL,
3301     };
3302     static _PyArg_Parser _parser = {"s#O|ssO!O!:CollectionProperty", _keywords, 0};
3303     if (!_PyArg_ParseTupleAndKeywordsFast(args,
3304                                           kw,
3305                                           &_parser,
3306                                           &id,
3307                                           &id_len,
3308                                           &type,
3309                                           &name,
3310                                           &description,
3311                                           &PySet_Type,
3312                                           &pyopts,
3313                                           &PySet_Type,
3314                                           &py_tags)) {
3315       return NULL;
3316     }
3317
3318     BPY_PROPDEF_CHECK(CollectionProperty, property_flag_items);
3319
3320     ptype = pointer_type_from_py(type, "CollectionProperty(...):");
3321     if (!ptype) {
3322       return NULL;
3323     }
3324
3325     if (!RNA_struct_is_a(ptype, &RNA_PropertyGroup)) {
3326       PyErr_Format(PyExc_TypeError,
3327                    "CollectionProperty(...) expected an RNA type derived from %.200s",
3328                    RNA_struct_ui_name(&RNA_ID),
3329                    RNA_struct_ui_name(&RNA_PropertyGroup));
3330       return NULL;
3331     }
3332
3333     prop = RNA_def_collection_runtime(srna, id, ptype, name ? name : id, description);
3334     if (py_tags) {
3335       RNA_def_property_tags(prop, prop_tags);
3336     }
3337     if (pyopts) {
3338       bpy_prop_assign_flag(prop, opts);
3339     }
3340
3341     if (RNA_struct_idprops_contains_datablock(ptype)) {
3342       if (RNA_struct_is_a(srna, &RNA_PropertyGroup)) {
3343         RNA_def_struct_flag(srna, STRUCT_CONTAINS_DATABLOCK_IDPROPERTIES);
3344       }
3345     }
3346     RNA_def_property_duplicate_pointers(srna, prop);
3347   }
3348   Py_RETURN_NONE;
3349 }
3350
3351 PyDoc_STRVAR(BPy_RemoveProperty_doc,
3352              ".. function:: RemoveProperty(cls, attr)\n"
3353              "\n"
3354              "   Removes a dynamically defined property.\n"
3355              "\n"
3356              "   :arg cls: The class containing the property (must be a positional argument).\n"
3357              "   :type cls: type\n"
3358              "   :arg attr: Property name (must be passed as a keyword).\n"
3359              "   :type attr: string\n"
3360              "\n"
3361              ".. note:: Typically this function doesn't need to be accessed directly.\n"
3362              "   Instead use ``del cls.attr``\n");
3363 static PyObject *BPy_RemoveProperty(PyObject *self, PyObject *args, PyObject *kw)
3364 {
3365   StructRNA *srna;
3366
3367   if (PyTuple_GET_SIZE(args) == 1) {
3368     PyObject *ret;
3369     self = PyTuple_GET_ITEM(args, 0);
3370     args = PyTuple_New(0);
3371     ret = BPy_RemoveProperty(self, args, kw);
3372     Py_DECREF(args);
3373     return ret;
3374   }
3375   else if (PyTuple_GET_SIZE(args) > 1) {
3376     PyErr_SetString(PyExc_ValueError, "expected one positional arg, one keyword arg");
3377     return NULL;
3378   }
3379
3380   srna = srna_from_self(self, "RemoveProperty(...):");
3381   if (srna == NULL && PyErr_Occurred()) {
3382     return NULL; /* self's type was compatible but error getting the srna */
3383   }
3384   else if (srna == NULL) {
3385     PyErr_SetString(PyExc_TypeError, "RemoveProperty(): struct rna not available for this type");
3386     return NULL;
3387   }
3388   else {
3389     const char *id = NULL;
3390
3391     static const char *_keywords[] = {
3392         "attr",
3393         NULL,
3394     };
3395     static _PyArg_Parser _parser = {"s:RemoveProperty", _keywords, 0};
3396     if (!_PyArg_ParseTupleAndKeywordsFast(args, kw, &_parser, &id)) {
3397       return NULL;
3398     }
3399
3400     if (RNA_def_property_free_identifier(srna, id) != 1) {
3401       PyErr_Format(PyExc_TypeError, "RemoveProperty(): '%s' not a defined dynamic property", id);
3402       return NULL;
3403     }
3404   }
3405   Py_RETURN_NONE;
3406 }
3407
3408 static struct PyMethodDef props_methods[] = {
3409     {"BoolProperty",
3410      (PyCFunction)BPy_BoolProperty,
3411      METH_VARARGS | METH_KEYWORDS,
3412      BPy_BoolProperty_doc},
3413     {"BoolVectorProperty",
3414      (PyCFunction)BPy_BoolVectorProperty,
3415      METH_VARARGS | METH_KEYWORDS,
3416      BPy_BoolVectorProperty_doc},
3417     {"IntProperty",
3418      (PyCFunction)BPy_IntProperty,
3419      METH_VARARGS | METH_KEYWORDS,
3420      BPy_IntProperty_doc},
3421     {"IntVectorProperty",
3422      (PyCFunction)BPy_IntVectorProperty,
3423      METH_VARARGS | METH_KEYWORDS,
3424      BPy_IntVectorProperty_doc},
3425     {"FloatProperty",
3426      (PyCFunction)BPy_FloatProperty,
3427      METH_VARARGS | METH_KEYWORDS,
3428      BPy_FloatProperty_doc},
3429     {"FloatVectorProperty",
3430      (PyCFunction)BPy_FloatVectorProperty,
3431      METH_VARARGS | METH_KEYWORDS,
3432      BPy_FloatVectorProperty_doc},
3433     {"StringProperty",
3434      (PyCFunction)BPy_StringProperty,
3435      METH_VARARGS | METH_KEYWORDS,
3436      BPy_StringProperty_doc},
3437     {"EnumProperty",
3438      (PyCFunction)BPy_EnumProperty,
3439      METH_VARARGS | METH_KEYWORDS,
3440      BPy_EnumProperty_doc},
3441     {"PointerProperty",
3442      (PyCFunction)BPy_PointerProperty,
3443      METH_VARARGS | METH_KEYWORDS,
3444      BPy_PointerProperty_doc},
3445     {"CollectionProperty",
3446      (PyCFunction)BPy_CollectionProperty,
3447      METH_VARARGS | METH_KEYWORDS,
3448      BPy_CollectionProperty_doc},
3449
3450     {"RemoveProperty",
3451      (PyCFunction)BPy_RemoveProperty,
3452      METH_VARARGS | METH_KEYWORDS,
3453      BPy_RemoveProperty_doc},
3454     {NULL, NULL, 0, NULL},
3455 };
3456
3457 static struct PyModuleDef props_module = {
3458     PyModuleDef_HEAD_INIT,
3459     "bpy.props",
3460     "This module defines properties to extend Blender's internal data. The result of these "
3461     "functions"
3462     " is used to assign properties to classes registered with Blender and can't be used "
3463     "directly.\n"
3464     "\n"
3465     ".. note:: All parameters to these functions must be passed as keywords.\n",
3466     -1, /* multiple "initialization" just copies the module dict. */
3467     props_methods,
3468     NULL,
3469     NULL,
3470     NULL,
3471     NULL,
3472 };
3473
3474 PyObject *BPY_rna_props(void)
3475 {
3476   PyObject *submodule;
3477   PyObject *submodule_dict;
3478
3479   submodule = PyModule_Create(&props_module);
3480   PyDict_SetItemString(PyImport_GetModuleDict(), props_module.m_name, submodule);
3481
3482   /* api needs the PyObjects internally */
3483   submodule_dict = PyModule_GetDict(submodule);
3484
3485 #define ASSIGN_STATIC(_name) pymeth_##_name = PyDict_GetItemString(submodule_dict, #_name)
3486
3487   ASSIGN_STATIC(BoolProperty);
3488   ASSIGN_STATIC(BoolVectorProperty);
3489   ASSIGN_STATIC(IntProperty);
3490   ASSIGN_STATIC(IntVectorProperty);
3491   ASSIGN_STATIC(FloatProperty);
3492   ASSIGN_STATIC(FloatVectorProperty);
3493   ASSIGN_STATIC(StringProperty);
3494   ASSIGN_STATIC(EnumProperty);
3495   ASSIGN_STATIC(PointerProperty);
3496   ASSIGN_STATIC(CollectionProperty);
3497   ASSIGN_STATIC(RemoveProperty);
3498
3499   return submodule;
3500 }