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