Python: Enable MASS unit in FloatProperty
[blender.git] / source / blender / makesrna / intern / rna_rna.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation (2008).
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_rna.c
24  *  \ingroup RNA
25  */
26
27 #include <stdlib.h>
28
29 #include "DNA_ID.h"
30
31 #include "BLI_utildefines.h"
32
33 #include "RNA_access.h"
34 #include "RNA_define.h"
35 #include "RNA_enum_types.h"
36
37 #include "rna_internal.h"
38
39 /* -------------------------------------------------------------------- */
40 /** \name Generic Enum's
41  * \{ */
42
43 /* Reuse for dynamic types  */
44 const EnumPropertyItem DummyRNA_NULL_items[] = {
45         {0, NULL, 0, NULL, NULL}
46 };
47
48 /* Reuse for dynamic types with default value */
49 const EnumPropertyItem DummyRNA_DEFAULT_items[] = {
50         {0, "DEFAULT", 0, "Default", ""},
51         {0, NULL, 0, NULL, NULL}
52 };
53
54 /** \} */
55
56 /* -------------------------------------------------------------------- */
57 /** \name RNA Enum's
58  * \{ */
59
60
61 const EnumPropertyItem rna_enum_property_type_items[] = {
62         {PROP_BOOLEAN, "BOOLEAN", 0, "Boolean", ""},
63         {PROP_INT, "INT", 0, "Integer", ""},
64         {PROP_FLOAT, "FLOAT", 0, "Float", ""},
65         {PROP_STRING, "STRING", 0, "String", ""},
66         {PROP_ENUM, "ENUM", 0, "Enumeration", ""},
67         {PROP_POINTER, "POINTER", 0, "Pointer", ""},
68         {PROP_COLLECTION, "COLLECTION", 0, "Collection", ""},
69         {0, NULL, 0, NULL, NULL}
70 };
71
72 /* XXX Keep in sync with bpy_props.c's property_subtype_xxx_items ???
73  *     Currently it is not...
74  */
75 const EnumPropertyItem rna_enum_property_subtype_items[] = {
76         {PROP_NONE, "NONE", 0, "None", ""},
77
78         /* strings */
79         {PROP_FILEPATH, "FILEPATH", 0, "File Path", ""},
80         {PROP_DIRPATH, "DIRPATH", 0, "Directory Path", ""},
81         {PROP_FILENAME, "FILENAME", 0, "File Name", ""},
82         {PROP_PASSWORD, "PASSWORD", 0, "Password", "A string that is displayed hidden ('********')"},
83
84         /* numbers */
85         {PROP_PIXEL, "PIXEL", 0, "Pixel", ""},
86         {PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned", ""},
87         {PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", ""},
88         {PROP_FACTOR, "FACTOR", 0, "Factor", ""},
89         {PROP_ANGLE, "ANGLE", 0, "Angle", ""},
90         {PROP_TIME, "TIME", 0, "Time", ""},
91         {PROP_DISTANCE, "DISTANCE", 0, "Distance", ""},
92         {PROP_DISTANCE_CAMERA, "DISTANCE_CAMERA", 0, "Camera Distance", ""},
93
94         /* number arrays */
95         {PROP_COLOR, "COLOR", 0, "Color", ""},
96         {PROP_TRANSLATION, "TRANSLATION", 0, "Translation", ""},
97         {PROP_DIRECTION, "DIRECTION", 0, "Direction", ""},
98         {PROP_VELOCITY, "VELOCITY", 0, "Velocity", ""},
99         {PROP_ACCELERATION, "ACCELERATION", 0, "Acceleration", ""},
100         {PROP_MATRIX, "MATRIX", 0, "Matrix", ""},
101         {PROP_EULER, "EULER", 0, "Euler Angles", ""},
102         {PROP_QUATERNION, "QUATERNION", 0, "Quaternion", ""},
103         {PROP_AXISANGLE, "AXISANGLE", 0, "Axis-Angle", ""},
104         {PROP_XYZ, "XYZ", 0, "XYZ", ""},
105         {PROP_XYZ_LENGTH, "XYZ_LENGTH", 0, "XYZ Length", ""},
106         {PROP_COLOR_GAMMA, "COLOR_GAMMA", 0, "Color", ""},
107         {PROP_COORDS, "COORDS", 0, "Coordinates", ""},
108
109         /* booleans */
110         {PROP_LAYER, "LAYER", 0, "Layer", ""},
111         {PROP_LAYER_MEMBER, "LAYER_MEMBER", 0, "Layer Member", ""},
112         {0, NULL, 0, NULL, NULL}
113 };
114
115 const EnumPropertyItem rna_enum_property_unit_items[] = {
116         {PROP_UNIT_NONE, "NONE", 0, "None", ""},
117         {PROP_UNIT_LENGTH, "LENGTH", 0, "Length", ""},
118         {PROP_UNIT_AREA, "AREA", 0, "Area", ""},
119         {PROP_UNIT_VOLUME, "VOLUME", 0, "Volume", ""},
120         {PROP_UNIT_ROTATION, "ROTATION", 0, "Rotation", ""},
121         {PROP_UNIT_TIME, "TIME", 0, "Time", ""},
122         {PROP_UNIT_VELOCITY, "VELOCITY", 0, "Velocity", ""},
123         {PROP_UNIT_ACCELERATION, "ACCELERATION", 0, "Acceleration", ""},
124         {PROP_UNIT_MASS, "MASS", 0, "Mass", ""},
125         {PROP_UNIT_CAMERA, "CAMERA", 0, "Camera", ""},
126         {0, NULL, 0, NULL, NULL}
127 };
128
129 /** \} */
130
131 #ifdef RNA_RUNTIME
132 #include "MEM_guardedalloc.h"
133 #include "BLI_ghash.h"
134
135 /* Struct */
136
137 static void rna_Struct_identifier_get(PointerRNA *ptr, char *value)
138 {
139         strcpy(value, ((StructRNA *)ptr->data)->identifier);
140 }
141
142 static int rna_Struct_identifier_length(PointerRNA *ptr)
143 {
144         return strlen(((StructRNA *)ptr->data)->identifier);
145 }
146
147 static void rna_Struct_description_get(PointerRNA *ptr, char *value)
148 {
149         strcpy(value, ((StructRNA *)ptr->data)->description);
150 }
151
152 static int rna_Struct_description_length(PointerRNA *ptr)
153 {
154         return strlen(((StructRNA *)ptr->data)->description);
155 }
156
157 static void rna_Struct_name_get(PointerRNA *ptr, char *value)
158 {
159         strcpy(value, ((StructRNA *)ptr->data)->name);
160 }
161
162 static int rna_Struct_name_length(PointerRNA *ptr)
163 {
164         return strlen(((StructRNA *)ptr->data)->name);
165 }
166
167 static void rna_Struct_translation_context_get(PointerRNA *ptr, char *value)
168 {
169         strcpy(value, ((StructRNA *)ptr->data)->translation_context);
170 }
171
172 static int rna_Struct_translation_context_length(PointerRNA *ptr)
173 {
174         return strlen(((StructRNA *)ptr->data)->translation_context);
175 }
176
177 static PointerRNA rna_Struct_base_get(PointerRNA *ptr)
178 {
179         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((StructRNA *)ptr->data)->base);
180 }
181
182 static PointerRNA rna_Struct_nested_get(PointerRNA *ptr)
183 {
184         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((StructRNA *)ptr->data)->nested);
185 }
186
187 static PointerRNA rna_Struct_name_property_get(PointerRNA *ptr)
188 {
189         return rna_pointer_inherit_refine(ptr, &RNA_Property, ((StructRNA *)ptr->data)->nameproperty);
190 }
191
192 /* Struct property iteration. This is quite complicated, the purpose is to
193  * iterate over properties of all inheritance levels, and for each struct to
194  * also iterator over id properties not known by RNA. */
195
196 static int rna_idproperty_known(CollectionPropertyIterator *iter, void *data)
197 {
198         IDProperty *idprop = (IDProperty *)data;
199         PropertyRNA *prop;
200         StructRNA *ptype = iter->builtin_parent.type;
201
202         /* function to skip any id properties that are already known by RNA,
203          * for the second loop where we go over unknown id properties */
204         do {
205                 for (prop = ptype->cont.properties.first; prop; prop = prop->next)
206                         if ((prop->flag_internal & PROP_INTERN_BUILTIN) == 0 && STREQ(prop->identifier, idprop->name))
207                                 return 1;
208         } while ((ptype = ptype->base));
209
210         return 0;
211 }
212
213 static int rna_property_builtin(CollectionPropertyIterator *UNUSED(iter), void *data)
214 {
215         PropertyRNA *prop = (PropertyRNA *)data;
216
217         /* function to skip builtin rna properties */
218
219         return (prop->flag_internal & PROP_INTERN_BUILTIN);
220 }
221
222 static int rna_function_builtin(CollectionPropertyIterator *UNUSED(iter), void *data)
223 {
224         FunctionRNA *func = (FunctionRNA *)data;
225
226         /* function to skip builtin rna functions */
227
228         return (func->flag & FUNC_BUILTIN);
229 }
230
231 static void rna_inheritance_next_level_restart(CollectionPropertyIterator *iter, IteratorSkipFunc skip, int funcs)
232 {
233         /* RNA struct inheritance */
234         while (!iter->valid && iter->level > 0) {
235                 StructRNA *srna;
236                 int i;
237
238                 srna = (StructRNA *)iter->parent.data;
239                 iter->level--;
240                 for (i = iter->level; i > 0; i--)
241                         srna = srna->base;
242
243                 rna_iterator_listbase_end(iter);
244
245                 if (funcs)
246                         rna_iterator_listbase_begin(iter, &srna->functions, skip);
247                 else
248                         rna_iterator_listbase_begin(iter, &srna->cont.properties, skip);
249         }
250 }
251
252 static void rna_inheritance_properties_listbase_begin(CollectionPropertyIterator *iter, ListBase *lb,
253                                                       IteratorSkipFunc skip)
254 {
255         rna_iterator_listbase_begin(iter, lb, skip);
256         rna_inheritance_next_level_restart(iter, skip, 0);
257 }
258
259 static void rna_inheritance_properties_listbase_next(CollectionPropertyIterator *iter, IteratorSkipFunc skip)
260 {
261         rna_iterator_listbase_next(iter);
262         rna_inheritance_next_level_restart(iter, skip, 0);
263 }
264
265 static void rna_inheritance_functions_listbase_begin(CollectionPropertyIterator *iter, ListBase *lb,
266                                                      IteratorSkipFunc skip)
267 {
268         rna_iterator_listbase_begin(iter, lb, skip);
269         rna_inheritance_next_level_restart(iter, skip, 1);
270 }
271
272 static void rna_inheritance_functions_listbase_next(CollectionPropertyIterator *iter, IteratorSkipFunc skip)
273 {
274         rna_iterator_listbase_next(iter);
275         rna_inheritance_next_level_restart(iter, skip, 1);
276 }
277
278 static void rna_Struct_properties_next(CollectionPropertyIterator *iter)
279 {
280         ListBaseIterator *internal = &iter->internal.listbase;
281         IDProperty *group;
282
283         if (internal->flag) {
284                 /* id properties */
285                 rna_iterator_listbase_next(iter);
286         }
287         else {
288                 /* regular properties */
289                 rna_inheritance_properties_listbase_next(iter, rna_property_builtin);
290
291                 /* try id properties */
292                 if (!iter->valid) {
293                         group = RNA_struct_idprops(&iter->builtin_parent, 0);
294
295                         if (group) {
296                                 rna_iterator_listbase_end(iter);
297                                 rna_iterator_listbase_begin(iter, &group->data.group, rna_idproperty_known);
298                                 internal = &iter->internal.listbase;
299                                 internal->flag = 1;
300                         }
301                 }
302         }
303 }
304
305 static void rna_Struct_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
306 {
307         StructRNA *srna;
308
309         /* here ptr->data should always be the same as iter->parent.type */
310         srna = (StructRNA *)ptr->data;
311
312         while (srna->base) {
313                 iter->level++;
314                 srna = srna->base;
315         }
316
317         rna_inheritance_properties_listbase_begin(iter, &srna->cont.properties, rna_property_builtin);
318 }
319
320 static PointerRNA rna_Struct_properties_get(CollectionPropertyIterator *iter)
321 {
322         ListBaseIterator *internal = &iter->internal.listbase;
323
324         /* we return either PropertyRNA* or IDProperty*, the rna_access.c
325          * functions can handle both as PropertyRNA* with some tricks */
326         return rna_pointer_inherit_refine(&iter->parent, &RNA_Property, internal->link);
327 }
328
329 static void rna_Struct_functions_next(CollectionPropertyIterator *iter)
330 {
331         rna_inheritance_functions_listbase_next(iter, rna_function_builtin);
332 }
333
334 static void rna_Struct_functions_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
335 {
336         StructRNA *srna;
337
338         /* here ptr->data should always be the same as iter->parent.type */
339         srna = (StructRNA *)ptr->data;
340
341         while (srna->base) {
342                 iter->level++;
343                 srna = srna->base;
344         }
345
346         rna_inheritance_functions_listbase_begin(iter, &srna->functions, rna_function_builtin);
347 }
348
349 static PointerRNA rna_Struct_functions_get(CollectionPropertyIterator *iter)
350 {
351         ListBaseIterator *internal = &iter->internal.listbase;
352
353         /* we return either PropertyRNA* or IDProperty*, the rna_access.c
354          * functions can handle both as PropertyRNA* with some tricks */
355         return rna_pointer_inherit_refine(&iter->parent, &RNA_Function, internal->link);
356 }
357
358 static void rna_Struct_property_tags_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
359 {
360         /* here ptr->data should always be the same as iter->parent.type */
361         StructRNA *srna = (StructRNA *)ptr->data;
362         const EnumPropertyItem *tag_defines = RNA_struct_property_tag_defines(srna);
363         unsigned int tag_count = tag_defines ? RNA_enum_items_count(tag_defines) : 0;
364
365         rna_iterator_array_begin(iter, (void *)tag_defines, sizeof(EnumPropertyItem), tag_count, 0, NULL);
366 }
367
368 /* Builtin properties iterator re-uses the Struct properties iterator, only
369  * difference is that we need to set the ptr data to the type of the struct
370  * whose properties we want to iterate over. */
371
372 void rna_builtin_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
373 {
374         PointerRNA newptr;
375
376         /* we create a new pointer with the type as the data */
377         newptr.type = &RNA_Struct;
378         newptr.data = ptr->type;
379
380         if (ptr->type->flag & STRUCT_ID)
381                 newptr.id.data = ptr->data;
382         else
383                 newptr.id.data = NULL;
384
385         iter->parent = newptr;
386         iter->builtin_parent = *ptr;
387
388         rna_Struct_properties_begin(iter, &newptr);
389 }
390
391 void rna_builtin_properties_next(CollectionPropertyIterator *iter)
392 {
393         rna_Struct_properties_next(iter);
394 }
395
396 PointerRNA rna_builtin_properties_get(CollectionPropertyIterator *iter)
397 {
398         return rna_Struct_properties_get(iter);
399 }
400
401 int rna_builtin_properties_lookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
402 {
403         StructRNA *srna;
404         PropertyRNA *prop;
405         PointerRNA propptr = {{NULL}};
406
407         srna = ptr->type;
408
409         do {
410                 if (srna->cont.prophash) {
411                         prop = BLI_ghash_lookup(srna->cont.prophash, (void *)key);
412
413                         if (prop) {
414                                 propptr.type = &RNA_Property;
415                                 propptr.data = prop;
416
417                                 *r_ptr = propptr;
418                                 return true;
419                         }
420                 }
421                 else {
422                         for (prop = srna->cont.properties.first; prop; prop = prop->next) {
423                                 if (!(prop->flag_internal & PROP_INTERN_BUILTIN) && STREQ(prop->identifier, key)) {
424                                         propptr.type = &RNA_Property;
425                                         propptr.data = prop;
426
427                                         *r_ptr = propptr;
428                                         return true;
429                                 }
430                         }
431                 }
432         } while ((srna = srna->base));
433
434         /* this was used pre 2.5beta0, now ID property access uses python's
435          * getitem style access
436          * - ob["foo"] rather than ob.foo */
437 #if 0
438         if (ptr->data) {
439                 IDProperty *group, *idp;
440
441                 group = RNA_struct_idprops(ptr, 0);
442
443                 if (group) {
444                         for (idp = group->data.group.first; idp; idp = idp->next) {
445                                 if (STREQ(idp->name, key)) {
446                                         propptr.type = &RNA_Property;
447                                         propptr.data = idp;
448
449                                         *r_ptr = propptr;
450                                         return true;
451                                 }
452                         }
453                 }
454         }
455 #endif
456         return false;
457 }
458
459 PointerRNA rna_builtin_type_get(PointerRNA *ptr)
460 {
461         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ptr->type);
462 }
463
464 /* Property */
465
466 static StructRNA *rna_Property_refine(PointerRNA *ptr)
467 {
468         PropertyRNA *prop = (PropertyRNA *)ptr->data;
469
470         rna_idproperty_check(&prop, ptr); /* XXX ptr? */
471
472         switch (prop->type) {
473                 case PROP_BOOLEAN: return &RNA_BoolProperty;
474                 case PROP_INT: return &RNA_IntProperty;
475                 case PROP_FLOAT: return &RNA_FloatProperty;
476                 case PROP_STRING: return &RNA_StringProperty;
477                 case PROP_ENUM: return &RNA_EnumProperty;
478                 case PROP_POINTER: return &RNA_PointerProperty;
479                 case PROP_COLLECTION: return &RNA_CollectionProperty;
480                 default: return &RNA_Property;
481         }
482 }
483
484 static void rna_Property_identifier_get(PointerRNA *ptr, char *value)
485 {
486         PropertyRNA *prop = (PropertyRNA *)ptr->data;
487         rna_idproperty_check(&prop, ptr);
488         strcpy(value, ((PropertyRNA *)prop)->identifier);
489 }
490
491 static int rna_Property_identifier_length(PointerRNA *ptr)
492 {
493         PropertyRNA *prop = (PropertyRNA *)ptr->data;
494         rna_idproperty_check(&prop, ptr);
495         return strlen(prop->identifier);
496 }
497
498 static void rna_Property_name_get(PointerRNA *ptr, char *value)
499 {
500         PropertyRNA *prop = (PropertyRNA *)ptr->data;
501         rna_idproperty_check(&prop, ptr);
502         strcpy(value, prop->name ? prop->name : "");
503 }
504
505 static int rna_Property_name_length(PointerRNA *ptr)
506 {
507         PropertyRNA *prop = (PropertyRNA *)ptr->data;
508         rna_idproperty_check(&prop, ptr);
509         return prop->name ? strlen(prop->name) : 0;
510 }
511
512 static void rna_Property_description_get(PointerRNA *ptr, char *value)
513 {
514         PropertyRNA *prop = (PropertyRNA *)ptr->data;
515         rna_idproperty_check(&prop, ptr);
516         strcpy(value, prop->description ? prop->description : "");
517 }
518 static int rna_Property_description_length(PointerRNA *ptr)
519 {
520         PropertyRNA *prop = (PropertyRNA *)ptr->data;
521         rna_idproperty_check(&prop, ptr);
522         return prop->description ? strlen(prop->description) : 0;
523 }
524
525 static void rna_Property_translation_context_get(PointerRNA *ptr, char *value)
526 {
527         PropertyRNA *prop = (PropertyRNA *)ptr->data;
528         rna_idproperty_check(&prop, ptr);
529         strcpy(value, prop->translation_context);
530 }
531
532 static int rna_Property_translation_context_length(PointerRNA *ptr)
533 {
534         PropertyRNA *prop = (PropertyRNA *)ptr->data;
535         rna_idproperty_check(&prop, ptr);
536         return strlen(prop->translation_context);
537 }
538
539 static int rna_Property_type_get(PointerRNA *ptr)
540 {
541         PropertyRNA *prop = (PropertyRNA *)ptr->data;
542         rna_idproperty_check(&prop, ptr);
543         return prop->type;
544 }
545
546 static int rna_Property_subtype_get(PointerRNA *ptr)
547 {
548         PropertyRNA *prop = (PropertyRNA *)ptr->data;
549         rna_idproperty_check(&prop, ptr);
550         return prop->subtype;
551 }
552
553 static PointerRNA rna_Property_srna_get(PointerRNA *ptr)
554 {
555         PropertyRNA *prop = (PropertyRNA *)ptr->data;
556         rna_idproperty_check(&prop, ptr);
557         return rna_pointer_inherit_refine(ptr, &RNA_Struct, prop->srna);
558 }
559
560 static int rna_Property_unit_get(PointerRNA *ptr)
561 {
562         PropertyRNA *prop = (PropertyRNA *)ptr->data;
563         rna_idproperty_check(&prop, ptr);
564         return RNA_SUBTYPE_UNIT(prop->subtype);
565 }
566
567 static int rna_Property_icon_get(PointerRNA *ptr)
568 {
569         PropertyRNA *prop = (PropertyRNA *)ptr->data;
570         rna_idproperty_check(&prop, ptr);
571         return prop->icon;
572 }
573
574 static bool rna_Property_readonly_get(PointerRNA *ptr)
575 {
576         PropertyRNA *prop = (PropertyRNA *)ptr->data;
577
578         /* don't use this because it will call functions that check the internal
579          * data for introspection we only need to know if it can be edited so the
580          * flag is better for this */
581 /*      return RNA_property_editable(ptr, prop); */
582         return (prop->flag & PROP_EDITABLE) == 0;
583 }
584
585 static bool rna_Property_animatable_get(PointerRNA *ptr)
586 {
587         PropertyRNA *prop = (PropertyRNA *)ptr->data;
588
589         return (prop->flag & PROP_ANIMATABLE) != 0;
590 }
591
592 static bool rna_Property_use_output_get(PointerRNA *ptr)
593 {
594         PropertyRNA *prop = (PropertyRNA *)ptr->data;
595         return (prop->flag_parameter & PARM_OUTPUT) != 0;
596 }
597
598 static bool rna_Property_is_required_get(PointerRNA *ptr)
599 {
600         PropertyRNA *prop = (PropertyRNA *)ptr->data;
601         return (prop->flag_parameter & PARM_REQUIRED) != 0;
602 }
603
604 static bool rna_Property_is_argument_optional_get(PointerRNA *ptr)
605 {
606         PropertyRNA *prop = (PropertyRNA *)ptr->data;
607         return (prop->flag_parameter & PARM_PYFUNC_OPTIONAL) != 0;
608 }
609
610 static bool rna_Property_is_never_none_get(PointerRNA *ptr)
611 {
612         PropertyRNA *prop = (PropertyRNA *)ptr->data;
613         return (prop->flag & PROP_NEVER_NULL) != 0;
614 }
615
616 static bool rna_Property_is_hidden_get(PointerRNA *ptr)
617 {
618         PropertyRNA *prop = (PropertyRNA *)ptr->data;
619         return (prop->flag & PROP_HIDDEN) != 0;
620 }
621
622 static bool rna_Property_is_skip_save_get(PointerRNA *ptr)
623 {
624         PropertyRNA *prop = (PropertyRNA *)ptr->data;
625         return (prop->flag & PROP_SKIP_SAVE) != 0;
626 }
627
628
629 static bool rna_Property_is_enum_flag_get(PointerRNA *ptr)
630 {
631         PropertyRNA *prop = (PropertyRNA *)ptr->data;
632         return (prop->flag & PROP_ENUM_FLAG) != 0;
633 }
634
635 static bool rna_Property_is_library_editable_flag_get(PointerRNA *ptr)
636 {
637         PropertyRNA *prop = (PropertyRNA *)ptr->data;
638         return (prop->flag & PROP_LIB_EXCEPTION) != 0;
639 }
640
641 static int rna_Property_tags_get(PointerRNA *ptr)
642 {
643         return RNA_property_tags(ptr->data);
644 }
645
646 static const EnumPropertyItem *rna_Property_tags_itemf(
647         bContext *UNUSED(C), PointerRNA *ptr,
648         PropertyRNA *UNUSED(prop), bool *r_free)
649 {
650         PropertyRNA *this_prop = (PropertyRNA *)ptr->data;
651         const StructRNA *srna = RNA_property_pointer_type(ptr, this_prop);
652         EnumPropertyItem *prop_tags;
653         EnumPropertyItem tmp = {0, "", 0, "", ""};
654         int totitem = 0;
655
656         for (const EnumPropertyItem *struct_tags = RNA_struct_property_tag_defines(srna);
657              struct_tags != NULL && struct_tags->identifier != NULL;
658              struct_tags++)
659         {
660                 memcpy(&tmp, struct_tags, sizeof(tmp));
661                 RNA_enum_item_add(&prop_tags, &totitem, &tmp);
662         }
663         RNA_enum_item_end(&prop_tags, &totitem);
664         *r_free = true;
665
666         return prop_tags;
667 }
668
669 static int rna_Property_array_length_get(PointerRNA *ptr)
670 {
671         PropertyRNA *prop = (PropertyRNA *)ptr->data;
672         rna_idproperty_check(&prop, ptr);
673         return prop->totarraylength;
674 }
675
676 static void rna_Property_array_dimensions_get(PointerRNA *ptr, int dimensions[RNA_MAX_ARRAY_DIMENSION])
677 {
678         PropertyRNA *prop = (PropertyRNA *)ptr->data;
679         rna_idproperty_check(&prop, ptr);
680
681         if (prop->arraydimension > 1) {
682                 for (int i = RNA_MAX_ARRAY_DIMENSION; i--; ) {
683                         dimensions[i] = (i >= prop->arraydimension) ? 0 : prop->arraylength[i];
684                 }
685         }
686         else {
687                 memset(dimensions, 0, sizeof(*dimensions) * RNA_MAX_ARRAY_DIMENSION);
688                 dimensions[0] = prop->totarraylength;
689         }
690 }
691
692 static bool rna_Property_is_registered_get(PointerRNA *ptr)
693 {
694         PropertyRNA *prop = (PropertyRNA *)ptr->data;
695         return (prop->flag & PROP_REGISTER) != 0;
696 }
697
698 static bool rna_Property_is_registered_optional_get(PointerRNA *ptr)
699 {
700         PropertyRNA *prop = (PropertyRNA *)ptr->data;
701         return (prop->flag & PROP_REGISTER_OPTIONAL) != 0;
702 }
703
704 static bool rna_Property_is_runtime_get(PointerRNA *ptr)
705 {
706         PropertyRNA *prop = (PropertyRNA *)ptr->data;
707         return (prop->flag_internal & PROP_INTERN_RUNTIME) != 0;
708 }
709
710
711 static bool rna_BoolProperty_default_get(PointerRNA *ptr)
712 {
713         PropertyRNA *prop = (PropertyRNA *)ptr->data;
714         rna_idproperty_check(&prop, ptr);
715         return ((BoolPropertyRNA *)prop)->defaultvalue;
716 }
717
718 static int rna_IntProperty_default_get(PointerRNA *ptr)
719 {
720         PropertyRNA *prop = (PropertyRNA *)ptr->data;
721         rna_idproperty_check(&prop, ptr);
722         return ((IntPropertyRNA *)prop)->defaultvalue;
723 }
724 /* int/float/bool */
725 static int rna_NumberProperty_default_array_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
726 {
727         PropertyRNA *prop = (PropertyRNA *)ptr->data;
728         rna_idproperty_check(&prop, ptr);
729
730         length[0] = prop->totarraylength;
731
732         return length[0];
733 }
734 static bool rna_NumberProperty_is_array_get(PointerRNA *ptr)
735 {
736         PropertyRNA *prop = (PropertyRNA *)ptr->data;
737
738         return RNA_property_array_check(prop);
739 }
740
741 static void rna_IntProperty_default_array_get(PointerRNA *ptr, int *values)
742 {
743         PropertyRNA *prop = (PropertyRNA *)ptr->data;
744         IntPropertyRNA *nprop = (IntPropertyRNA *)prop;
745         rna_idproperty_check(&prop, ptr);
746
747         if (nprop->defaultarray) {
748                 memcpy(values, nprop->defaultarray, prop->totarraylength * sizeof(int));
749         }
750         else {
751                 int i;
752                 for (i = 0; i < prop->totarraylength; i++)
753                         values[i] = nprop->defaultvalue;
754         }
755 }
756 static void rna_BoolProperty_default_array_get(PointerRNA *ptr, bool *values)
757 {
758         PropertyRNA *prop = (PropertyRNA *)ptr->data;
759         BoolPropertyRNA *nprop = (BoolPropertyRNA *)prop;
760         rna_idproperty_check(&prop, ptr);
761
762         if (nprop->defaultarray) {
763                 memcpy(values, nprop->defaultarray, prop->totarraylength * sizeof(bool));
764         }
765         else {
766                 int i;
767                 for (i = 0; i < prop->totarraylength; i++)
768                         values[i] = nprop->defaultvalue;
769         }
770 }
771 static void rna_FloatProperty_default_array_get(PointerRNA *ptr, float *values)
772 {
773         PropertyRNA *prop = (PropertyRNA *)ptr->data;
774         FloatPropertyRNA *nprop = (FloatPropertyRNA *)prop;
775         rna_idproperty_check(&prop, ptr);
776
777         if (nprop->defaultarray) {
778                 memcpy(values, nprop->defaultarray, prop->totarraylength * sizeof(float));
779         }
780         else {
781                 int i;
782                 for (i = 0; i < prop->totarraylength; i++)
783                         values[i] = nprop->defaultvalue;
784         }
785 }
786
787 static int rna_IntProperty_hard_min_get(PointerRNA *ptr)
788 {
789         PropertyRNA *prop = (PropertyRNA *)ptr->data;
790         rna_idproperty_check(&prop, ptr);
791         return ((IntPropertyRNA *)prop)->hardmin;
792 }
793
794 static int rna_IntProperty_hard_max_get(PointerRNA *ptr)
795 {
796         PropertyRNA *prop = (PropertyRNA *)ptr->data;
797         rna_idproperty_check(&prop, ptr);
798         return ((IntPropertyRNA *)prop)->hardmax;
799 }
800
801 static int rna_IntProperty_soft_min_get(PointerRNA *ptr)
802 {
803         PropertyRNA *prop = (PropertyRNA *)ptr->data;
804         rna_idproperty_check(&prop, ptr);
805         return ((IntPropertyRNA *)prop)->softmin;
806 }
807
808 static int rna_IntProperty_soft_max_get(PointerRNA *ptr)
809 {
810         PropertyRNA *prop = (PropertyRNA *)ptr->data;
811         rna_idproperty_check(&prop, ptr);
812         return ((IntPropertyRNA *)prop)->softmax;
813 }
814
815 static int rna_IntProperty_step_get(PointerRNA *ptr)
816 {
817         PropertyRNA *prop = (PropertyRNA *)ptr->data;
818         rna_idproperty_check(&prop, ptr);
819         return ((IntPropertyRNA *)prop)->step;
820 }
821
822 static float rna_FloatProperty_default_get(PointerRNA *ptr)
823 {
824         PropertyRNA *prop = (PropertyRNA *)ptr->data;
825         rna_idproperty_check(&prop, ptr);
826         return ((FloatPropertyRNA *)prop)->defaultvalue;
827 }
828 static float rna_FloatProperty_hard_min_get(PointerRNA *ptr)
829 {
830         PropertyRNA *prop = (PropertyRNA *)ptr->data;
831         rna_idproperty_check(&prop, ptr);
832         return ((FloatPropertyRNA *)prop)->hardmin;
833 }
834
835 static float rna_FloatProperty_hard_max_get(PointerRNA *ptr)
836 {
837         PropertyRNA *prop = (PropertyRNA *)ptr->data;
838         rna_idproperty_check(&prop, ptr);
839         return ((FloatPropertyRNA *)prop)->hardmax;
840 }
841
842 static float rna_FloatProperty_soft_min_get(PointerRNA *ptr)
843 {
844         PropertyRNA *prop = (PropertyRNA *)ptr->data;
845         rna_idproperty_check(&prop, ptr);
846         return ((FloatPropertyRNA *)prop)->softmin;
847 }
848
849 static float rna_FloatProperty_soft_max_get(PointerRNA *ptr)
850 {
851         PropertyRNA *prop = (PropertyRNA *)ptr->data;
852         rna_idproperty_check(&prop, ptr);
853         return ((FloatPropertyRNA *)prop)->softmax;
854 }
855
856 static float rna_FloatProperty_step_get(PointerRNA *ptr)
857 {
858         PropertyRNA *prop = (PropertyRNA *)ptr->data;
859         rna_idproperty_check(&prop, ptr);
860         return ((FloatPropertyRNA *)prop)->step;
861 }
862
863 static int rna_FloatProperty_precision_get(PointerRNA *ptr)
864 {
865         PropertyRNA *prop = (PropertyRNA *)ptr->data;
866         rna_idproperty_check(&prop, ptr);
867         return ((FloatPropertyRNA *)prop)->precision;
868 }
869
870 static void rna_StringProperty_default_get(PointerRNA *ptr, char *value)
871 {
872         PropertyRNA *prop = (PropertyRNA *)ptr->data;
873         rna_idproperty_check(&prop, ptr);
874         strcpy(value, ((StringPropertyRNA *)prop)->defaultvalue);
875 }
876 static int rna_StringProperty_default_length(PointerRNA *ptr)
877 {
878         PropertyRNA *prop = (PropertyRNA *)ptr->data;
879         rna_idproperty_check(&prop, ptr);
880         return strlen(((StringPropertyRNA *)prop)->defaultvalue);
881 }
882
883 static int rna_StringProperty_max_length_get(PointerRNA *ptr)
884 {
885         PropertyRNA *prop = (PropertyRNA *)ptr->data;
886         rna_idproperty_check(&prop, ptr);
887         return ((StringPropertyRNA *)prop)->maxlength;
888 }
889
890 static const EnumPropertyItem *rna_EnumProperty_default_itemf(bContext *C, PointerRNA *ptr,
891                                                         PropertyRNA *prop_parent, bool *r_free)
892 {
893         PropertyRNA *prop = (PropertyRNA *)ptr->data;
894         EnumPropertyRNA *eprop;
895
896         rna_idproperty_check(&prop, ptr);
897         eprop = (EnumPropertyRNA *)prop;
898
899         /* incompatible default attributes */
900         if ((prop_parent->flag & PROP_ENUM_FLAG) != (prop->flag & PROP_ENUM_FLAG)) {
901                 return DummyRNA_NULL_items;
902         }
903
904         if ((eprop->itemf == NULL) ||
905             (eprop->itemf == rna_EnumProperty_default_itemf) ||
906             (ptr->type == &RNA_EnumProperty) ||
907             (C == NULL))
908         {
909                 if (eprop->item) {
910                         return eprop->item;
911                 }
912         }
913
914         return eprop->itemf(C, ptr, prop, r_free);
915 }
916
917 /* XXX - not sure this is needed? */
918 static int rna_EnumProperty_default_get(PointerRNA *ptr)
919 {
920         PropertyRNA *prop = (PropertyRNA *)ptr->data;
921         rna_idproperty_check(&prop, ptr);
922         return ((EnumPropertyRNA *)prop)->defaultvalue;
923 }
924
925 static int rna_enum_check_separator(CollectionPropertyIterator *UNUSED(iter), void *data)
926 {
927         EnumPropertyItem *item = (EnumPropertyItem *)data;
928
929         return (item->identifier[0] == 0);
930 }
931
932 static void rna_EnumProperty_items_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
933 {
934         PropertyRNA *prop = (PropertyRNA *)ptr->data;
935         /* EnumPropertyRNA *eprop;  *//* UNUSED */
936         const EnumPropertyItem *item = NULL;
937         int totitem;
938         bool free;
939
940         rna_idproperty_check(&prop, ptr);
941         /* eprop = (EnumPropertyRNA *)prop; */
942
943         RNA_property_enum_items_ex(
944                     NULL, ptr, prop, STREQ(iter->prop->identifier, "enum_items_static"), &item, &totitem, &free);
945         rna_iterator_array_begin(iter, (void *)item, sizeof(EnumPropertyItem), totitem, free, rna_enum_check_separator);
946 }
947
948 static void rna_EnumPropertyItem_identifier_get(PointerRNA *ptr, char *value)
949 {
950         strcpy(value, ((EnumPropertyItem *)ptr->data)->identifier);
951 }
952
953 static int rna_EnumPropertyItem_identifier_length(PointerRNA *ptr)
954 {
955         return strlen(((EnumPropertyItem *)ptr->data)->identifier);
956 }
957
958 static void rna_EnumPropertyItem_name_get(PointerRNA *ptr, char *value)
959 {
960         strcpy(value, ((EnumPropertyItem *)ptr->data)->name);
961 }
962
963 static int rna_EnumPropertyItem_name_length(PointerRNA *ptr)
964 {
965         return strlen(((EnumPropertyItem *)ptr->data)->name);
966 }
967
968 static void rna_EnumPropertyItem_description_get(PointerRNA *ptr, char *value)
969 {
970         EnumPropertyItem *eprop = (EnumPropertyItem *)ptr->data;
971
972         if (eprop->description)
973                 strcpy(value, eprop->description);
974         else
975                 value[0] = '\0';
976 }
977
978 static int rna_EnumPropertyItem_description_length(PointerRNA *ptr)
979 {
980         EnumPropertyItem *eprop = (EnumPropertyItem *)ptr->data;
981
982         if (eprop->description)
983                 return strlen(eprop->description);
984         else
985                 return 0;
986 }
987
988 static int rna_EnumPropertyItem_value_get(PointerRNA *ptr)
989 {
990         return ((EnumPropertyItem *)ptr->data)->value;
991 }
992
993 static int rna_EnumPropertyItem_icon_get(PointerRNA *ptr)
994 {
995         return ((EnumPropertyItem *)ptr->data)->icon;
996 }
997
998 static PointerRNA rna_PointerProperty_fixed_type_get(PointerRNA *ptr)
999 {
1000         PropertyRNA *prop = (PropertyRNA *)ptr->data;
1001         rna_idproperty_check(&prop, ptr);
1002         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((PointerPropertyRNA *)prop)->type);
1003 }
1004
1005 static PointerRNA rna_CollectionProperty_fixed_type_get(PointerRNA *ptr)
1006 {
1007         PropertyRNA *prop = (PropertyRNA *)ptr->data;
1008         rna_idproperty_check(&prop, ptr);
1009         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((CollectionPropertyRNA *)prop)->item_type);
1010 }
1011
1012 /* Function */
1013
1014 static void rna_Function_identifier_get(PointerRNA *ptr, char *value)
1015 {
1016         strcpy(value, ((FunctionRNA *)ptr->data)->identifier);
1017 }
1018
1019 static int rna_Function_identifier_length(PointerRNA *ptr)
1020 {
1021         return strlen(((FunctionRNA *)ptr->data)->identifier);
1022 }
1023
1024 static void rna_Function_description_get(PointerRNA *ptr, char *value)
1025 {
1026         strcpy(value, ((FunctionRNA *)ptr->data)->description);
1027 }
1028
1029 static int rna_Function_description_length(PointerRNA *ptr)
1030 {
1031         return strlen(((FunctionRNA *)ptr->data)->description);
1032 }
1033
1034 static void rna_Function_parameters_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
1035 {
1036         rna_iterator_listbase_begin(iter, &((FunctionRNA *)ptr->data)->cont.properties, rna_property_builtin);
1037 }
1038
1039 static bool rna_Function_registered_get(PointerRNA *ptr)
1040 {
1041         FunctionRNA *func = (FunctionRNA *)ptr->data;
1042         return 0 != (func->flag & FUNC_REGISTER);
1043 }
1044
1045 static bool rna_Function_registered_optional_get(PointerRNA *ptr)
1046 {
1047         FunctionRNA *func = (FunctionRNA *)ptr->data;
1048         return 0 != (func->flag & (FUNC_REGISTER_OPTIONAL & ~FUNC_REGISTER));
1049 }
1050
1051 static bool rna_Function_no_self_get(PointerRNA *ptr)
1052 {
1053         FunctionRNA *func = (FunctionRNA *)ptr->data;
1054         return !(func->flag & FUNC_NO_SELF);
1055 }
1056
1057 static int rna_Function_use_self_type_get(PointerRNA *ptr)
1058 {
1059         FunctionRNA *func = (FunctionRNA *)ptr->data;
1060         return 0 != (func->flag & FUNC_USE_SELF_TYPE);
1061 }
1062
1063 /* Blender RNA */
1064
1065 static int rna_struct_is_publc(CollectionPropertyIterator *UNUSED(iter), void *data)
1066 {
1067         StructRNA *srna = data;
1068
1069         return !(srna->flag & STRUCT_PUBLIC_NAMESPACE);
1070 }
1071
1072
1073 static void rna_BlenderRNA_structs_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
1074 {
1075         BlenderRNA *brna = ptr->data;
1076         rna_iterator_listbase_begin(iter, &brna->structs, rna_struct_is_publc);
1077 }
1078
1079 /* optional, for faster lookups */
1080 static int rna_BlenderRNA_structs_length(PointerRNA *ptr)
1081 {
1082         BlenderRNA *brna = ptr->data;
1083         BLI_assert(brna->structs_len == BLI_listbase_count(&brna->structs));
1084         return brna->structs_len;
1085 }
1086 static int rna_BlenderRNA_structs_lookup_int(PointerRNA *ptr, int index, PointerRNA *r_ptr)
1087 {
1088         BlenderRNA *brna = ptr->data;
1089         StructRNA *srna = index < brna->structs_len ? BLI_findlink(&brna->structs, index) : NULL;
1090         if (srna != NULL) {
1091                 RNA_pointer_create(NULL, &RNA_Struct, srna, r_ptr);
1092                 return true;
1093         }
1094         else {
1095                 return false;
1096         }
1097 }
1098 static int rna_BlenderRNA_structs_lookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
1099 {
1100         BlenderRNA *brna = ptr->data;
1101         StructRNA *srna = BLI_ghash_lookup(brna->structs_map, (void *)key);
1102         if (srna != NULL) {
1103                 RNA_pointer_create(NULL, &RNA_Struct, srna, r_ptr);
1104                 return true;
1105         }
1106
1107         return false;
1108 }
1109
1110
1111 #else
1112
1113 static void rna_def_struct(BlenderRNA *brna)
1114 {
1115         StructRNA *srna;
1116         PropertyRNA *prop;
1117
1118         srna = RNA_def_struct(brna, "Struct", NULL);
1119         RNA_def_struct_ui_text(srna, "Struct Definition", "RNA structure definition");
1120         RNA_def_struct_ui_icon(srna, ICON_RNA);
1121
1122         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1123         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1124         RNA_def_property_string_funcs(prop, "rna_Struct_name_get", "rna_Struct_name_length", NULL);
1125         RNA_def_property_ui_text(prop, "Name", "Human readable name");
1126
1127         prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
1128         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1129         RNA_def_property_string_funcs(prop, "rna_Struct_identifier_get", "rna_Struct_identifier_length", NULL);
1130         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
1131         RNA_def_struct_name_property(srna, prop);
1132
1133         prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
1134         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1135         RNA_def_property_string_funcs(prop, "rna_Struct_description_get", "rna_Struct_description_length", NULL);
1136         RNA_def_property_ui_text(prop, "Description", "Description of the Struct's purpose");
1137
1138         prop = RNA_def_property(srna, "translation_context", PROP_STRING, PROP_NONE);
1139         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1140         RNA_def_property_string_funcs(prop, "rna_Struct_translation_context_get",
1141                                       "rna_Struct_translation_context_length", NULL);
1142         RNA_def_property_ui_text(prop, "Translation Context", "Translation context of the struct's name");
1143
1144         prop = RNA_def_property(srna, "base", PROP_POINTER, PROP_NONE);
1145         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1146         RNA_def_property_struct_type(prop, "Struct");
1147         RNA_def_property_pointer_funcs(prop, "rna_Struct_base_get", NULL, NULL, NULL);
1148         RNA_def_property_ui_text(prop, "Base", "Struct definition this is derived from");
1149
1150         prop = RNA_def_property(srna, "nested", PROP_POINTER, PROP_NONE);
1151         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1152         RNA_def_property_struct_type(prop, "Struct");
1153         RNA_def_property_pointer_funcs(prop, "rna_Struct_nested_get", NULL, NULL, NULL);
1154         RNA_def_property_ui_text(prop, "Nested",
1155                                  "Struct in which this struct is always nested, and to which it logically belongs");
1156
1157         prop = RNA_def_property(srna, "name_property", PROP_POINTER, PROP_NONE);
1158         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1159         RNA_def_property_struct_type(prop, "StringProperty");
1160         RNA_def_property_pointer_funcs(prop, "rna_Struct_name_property_get", NULL, NULL, NULL);
1161         RNA_def_property_ui_text(prop, "Name Property", "Property that gives the name of the struct");
1162
1163         prop = RNA_def_property(srna, "properties", PROP_COLLECTION, PROP_NONE);
1164         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1165         RNA_def_property_struct_type(prop, "Property");
1166         RNA_def_property_collection_funcs(prop, "rna_Struct_properties_begin", "rna_Struct_properties_next",
1167                                           "rna_iterator_listbase_end", "rna_Struct_properties_get",
1168                                           NULL, NULL, NULL, NULL);
1169         RNA_def_property_ui_text(prop, "Properties", "Properties in the struct");
1170
1171         prop = RNA_def_property(srna, "functions", PROP_COLLECTION, PROP_NONE);
1172         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1173         RNA_def_property_struct_type(prop, "Function");
1174         RNA_def_property_collection_funcs(prop, "rna_Struct_functions_begin", "rna_Struct_functions_next",
1175                                           "rna_iterator_listbase_end", "rna_Struct_functions_get",
1176                                           NULL, NULL, NULL, NULL);
1177         RNA_def_property_ui_text(prop, "Functions", "");
1178
1179         prop = RNA_def_property(srna, "property_tags", PROP_COLLECTION, PROP_NONE);
1180         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1181         RNA_def_property_struct_type(prop, "EnumPropertyItem");
1182         RNA_def_property_collection_funcs(prop, "rna_Struct_property_tags_begin", "rna_iterator_array_next",
1183                                           "rna_iterator_array_end", "rna_iterator_array_get",
1184                                           NULL, NULL, NULL, NULL);
1185         RNA_def_property_ui_text(prop, "Property Tags", "Tags that properties can use to influence behavior");
1186 }
1187
1188 static void rna_def_property(BlenderRNA *brna)
1189 {
1190         StructRNA *srna;
1191         PropertyRNA *prop;
1192         static const EnumPropertyItem subtype_items[] = {
1193                 {PROP_NONE, "NONE", 0, "None", ""},
1194                 {PROP_FILEPATH, "FILE_PATH", 0, "File Path", ""},
1195                 {PROP_DIRPATH, "DIR_PATH", 0, "Directory Path", ""},
1196                 {PROP_PIXEL, "PIXEL", 0, "Pixel", ""},
1197                 {PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned Number", ""},
1198                 {PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", ""},
1199                 {PROP_FACTOR, "FACTOR", 0, "Factor", ""},
1200                 {PROP_ANGLE, "ANGLE", 0, "Angle", ""},
1201                 {PROP_TIME, "TIME", 0, "Time", ""},
1202                 {PROP_DISTANCE, "DISTANCE", 0, "Distance", ""},
1203                 {PROP_COLOR, "COLOR", 0, "Color", ""},
1204                 {PROP_TRANSLATION, "TRANSLATION", 0, "Translation", ""},
1205                 {PROP_DIRECTION, "DIRECTION", 0, "Direction", ""},
1206                 {PROP_MATRIX, "MATRIX", 0, "Matrix", ""},
1207                 {PROP_EULER, "EULER", 0, "Euler", ""},
1208                 {PROP_QUATERNION, "QUATERNION", 0, "Quaternion", ""},
1209                 {PROP_XYZ, "XYZ", 0, "XYZ", ""},
1210                 {PROP_COLOR_GAMMA, "COLOR_GAMMA", 0, "Gamma Corrected Color", ""},
1211                 {PROP_COORDS, "COORDINATES", 0, "Vector Coordinates", ""},
1212                 {PROP_LAYER, "LAYER", 0, "Layer", ""},
1213                 {PROP_LAYER_MEMBER, "LAYER_MEMBERSHIP", 0, "Layer Membership", ""},
1214                 {0, NULL, 0, NULL, NULL}
1215         };
1216         EnumPropertyItem dummy_prop_tags[] = {
1217                 {0, NULL, 0, NULL, NULL}
1218         };
1219
1220         srna = RNA_def_struct(brna, "Property", NULL);
1221         RNA_def_struct_ui_text(srna, "Property Definition", "RNA property definition");
1222         RNA_def_struct_refine_func(srna, "rna_Property_refine");
1223         RNA_def_struct_ui_icon(srna, ICON_RNA);
1224
1225         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1226         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1227         RNA_def_property_string_funcs(prop, "rna_Property_name_get", "rna_Property_name_length", NULL);
1228         RNA_def_property_ui_text(prop, "Name", "Human readable name");
1229
1230         prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
1231         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1232         RNA_def_property_string_funcs(prop, "rna_Property_identifier_get", "rna_Property_identifier_length", NULL);
1233         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
1234         RNA_def_struct_name_property(srna, prop);
1235
1236         prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
1237         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1238         RNA_def_property_string_funcs(prop, "rna_Property_description_get", "rna_Property_description_length", NULL);
1239         RNA_def_property_ui_text(prop, "Description", "Description of the property for tooltips");
1240
1241         prop = RNA_def_property(srna, "translation_context", PROP_STRING, PROP_NONE);
1242         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1243         RNA_def_property_string_funcs(prop, "rna_Property_translation_context_get",
1244                                       "rna_Property_translation_context_length", NULL);
1245         RNA_def_property_ui_text(prop, "Translation Context", "Translation context of the property's name");
1246
1247         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1248         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1249         RNA_def_property_enum_items(prop, rna_enum_property_type_items);
1250         RNA_def_property_enum_funcs(prop, "rna_Property_type_get", NULL, NULL);
1251         RNA_def_property_ui_text(prop, "Type", "Data type of the property");
1252
1253         prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
1254         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1255         RNA_def_property_enum_items(prop, subtype_items);
1256         RNA_def_property_enum_funcs(prop, "rna_Property_subtype_get", NULL, NULL);
1257         RNA_def_property_ui_text(prop, "Subtype", "Semantic interpretation of the property");
1258
1259         prop = RNA_def_property(srna, "srna", PROP_POINTER, PROP_NONE);
1260         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1261         RNA_def_property_struct_type(prop, "Struct");
1262         RNA_def_property_pointer_funcs(prop, "rna_Property_srna_get", NULL, NULL, NULL);
1263         RNA_def_property_ui_text(prop, "Base", "Struct definition used for properties assigned to this item");
1264
1265         prop = RNA_def_property(srna, "unit", PROP_ENUM, PROP_NONE);
1266         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1267         RNA_def_property_enum_items(prop, rna_enum_property_unit_items);
1268         RNA_def_property_enum_funcs(prop, "rna_Property_unit_get", NULL, NULL);
1269         RNA_def_property_ui_text(prop, "Unit", "Type of units for this property");
1270
1271         prop = RNA_def_property(srna, "icon", PROP_ENUM, PROP_NONE);
1272         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1273         RNA_def_property_enum_items(prop, rna_enum_icon_items);
1274         RNA_def_property_enum_funcs(prop, "rna_Property_icon_get", NULL, NULL);
1275         RNA_def_property_ui_text(prop, "Icon", "Icon of the item");
1276
1277         prop = RNA_def_property(srna, "is_readonly", PROP_BOOLEAN, PROP_NONE);
1278         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1279         RNA_def_property_boolean_funcs(prop, "rna_Property_readonly_get", NULL);
1280         RNA_def_property_ui_text(prop, "Read Only", "Property is editable through RNA");
1281
1282         prop = RNA_def_property(srna, "is_animatable", PROP_BOOLEAN, PROP_NONE);
1283         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1284         RNA_def_property_boolean_funcs(prop, "rna_Property_animatable_get", NULL);
1285         RNA_def_property_ui_text(prop, "Animatable", "Property is animatable through RNA");
1286
1287         prop = RNA_def_property(srna, "is_required", PROP_BOOLEAN, PROP_NONE);
1288         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1289         RNA_def_property_boolean_funcs(prop, "rna_Property_is_required_get", NULL);
1290         RNA_def_property_ui_text(prop, "Required", "False when this property is an optional argument in an RNA function");
1291
1292         prop = RNA_def_property(srna, "is_argument_optional", PROP_BOOLEAN, PROP_NONE);
1293         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1294         RNA_def_property_boolean_funcs(prop, "rna_Property_is_argument_optional_get", NULL);
1295         RNA_def_property_ui_text(prop, "Optional Argument",
1296                                  "True when the property is optional in a Python function implementing an RNA function");
1297
1298         prop = RNA_def_property(srna, "is_never_none", PROP_BOOLEAN, PROP_NONE);
1299         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1300         RNA_def_property_boolean_funcs(prop, "rna_Property_is_never_none_get", NULL);
1301         RNA_def_property_ui_text(prop, "Never None", "True when this value can't be set to None");
1302
1303         prop = RNA_def_property(srna, "is_hidden", PROP_BOOLEAN, PROP_NONE);
1304         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1305         RNA_def_property_boolean_funcs(prop, "rna_Property_is_hidden_get", NULL);
1306         RNA_def_property_ui_text(prop, "Hidden", "True when the property is hidden");
1307
1308         prop = RNA_def_property(srna, "is_skip_save", PROP_BOOLEAN, PROP_NONE);
1309         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1310         RNA_def_property_boolean_funcs(prop, "rna_Property_is_skip_save_get", NULL);
1311         RNA_def_property_ui_text(prop, "Skip Save", "True when the property is not saved in presets");
1312
1313         prop = RNA_def_property(srna, "is_output", PROP_BOOLEAN, PROP_NONE);
1314         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1315         RNA_def_property_boolean_funcs(prop, "rna_Property_use_output_get", NULL);
1316         RNA_def_property_ui_text(prop, "Return", "True when this property is an output value from an RNA function");
1317
1318         prop = RNA_def_property(srna, "is_registered", PROP_BOOLEAN, PROP_NONE);
1319         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1320         RNA_def_property_boolean_funcs(prop, "rna_Property_is_registered_get", NULL);
1321         RNA_def_property_ui_text(prop, "Registered", "Property is registered as part of type registration");
1322
1323         prop = RNA_def_property(srna, "is_registered_optional", PROP_BOOLEAN, PROP_NONE);
1324         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1325         RNA_def_property_boolean_funcs(prop, "rna_Property_is_registered_optional_get", NULL);
1326         RNA_def_property_ui_text(prop, "Registered Optionally",
1327                                  "Property is optionally registered as part of type registration");
1328
1329         prop = RNA_def_property(srna, "is_runtime", PROP_BOOLEAN, PROP_NONE);
1330         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1331         RNA_def_property_boolean_funcs(prop, "rna_Property_is_runtime_get", NULL);
1332         RNA_def_property_ui_text(prop, "Runtime", "Property has been dynamically created at runtime");
1333
1334         prop = RNA_def_property(srna, "is_enum_flag", PROP_BOOLEAN, PROP_NONE);
1335         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1336         RNA_def_property_boolean_funcs(prop, "rna_Property_is_enum_flag_get", NULL);
1337         RNA_def_property_ui_text(prop, "Enum Flag", "True when multiple enums ");
1338
1339         prop = RNA_def_property(srna, "is_library_editable", PROP_BOOLEAN, PROP_NONE);
1340         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1341         RNA_def_property_boolean_funcs(prop, "rna_Property_is_library_editable_flag_get", NULL);
1342         RNA_def_property_ui_text(prop, "Library Editable", "Property is editable from linked instances (changes not saved)");
1343
1344         prop = RNA_def_property(srna, "tags", PROP_ENUM, PROP_NONE);
1345         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1346         RNA_def_property_enum_items(prop, dummy_prop_tags);
1347         RNA_def_property_enum_funcs(prop, "rna_Property_tags_get", NULL, "rna_Property_tags_itemf");
1348         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL | PROP_ENUM_FLAG);
1349         RNA_def_property_ui_text(prop, "Tags", "Subset of tags (defined in parent struct) that are set for this property");
1350 }
1351
1352 static void rna_def_function(BlenderRNA *brna)
1353 {
1354         StructRNA *srna;
1355         PropertyRNA *prop;
1356
1357         srna = RNA_def_struct(brna, "Function", NULL);
1358         RNA_def_struct_ui_text(srna, "Function Definition", "RNA function definition");
1359         RNA_def_struct_ui_icon(srna, ICON_RNA);
1360
1361         prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
1362         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1363         RNA_def_property_string_funcs(prop, "rna_Function_identifier_get", "rna_Function_identifier_length", NULL);
1364         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
1365         RNA_def_struct_name_property(srna, prop);
1366
1367         prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
1368         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1369         RNA_def_property_string_funcs(prop, "rna_Function_description_get", "rna_Function_description_length", NULL);
1370         RNA_def_property_ui_text(prop, "Description", "Description of the Function's purpose");
1371
1372         prop = RNA_def_property(srna, "parameters", PROP_COLLECTION, PROP_NONE);
1373         /*RNA_def_property_clear_flag(prop, PROP_EDITABLE);*/
1374         RNA_def_property_struct_type(prop, "Property");
1375         RNA_def_property_collection_funcs(prop, "rna_Function_parameters_begin", "rna_iterator_listbase_next",
1376                                           "rna_iterator_listbase_end", "rna_iterator_listbase_get",
1377                                           NULL, NULL, NULL, NULL);
1378         RNA_def_property_ui_text(prop, "Parameters", "Parameters for the function");
1379
1380         prop = RNA_def_property(srna, "is_registered", PROP_BOOLEAN, PROP_NONE);
1381         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1382         RNA_def_property_boolean_funcs(prop, "rna_Function_registered_get", NULL);
1383         RNA_def_property_ui_text(prop, "Registered", "Function is registered as callback as part of type registration");
1384
1385         prop = RNA_def_property(srna, "is_registered_optional", PROP_BOOLEAN, PROP_NONE);
1386         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1387         RNA_def_property_boolean_funcs(prop, "rna_Function_registered_optional_get", NULL);
1388         RNA_def_property_ui_text(prop, "Registered Optionally",
1389                                  "Function is optionally registered as callback part of type registration");
1390
1391         prop = RNA_def_property(srna, "use_self", PROP_BOOLEAN, PROP_NONE);
1392         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1393         RNA_def_property_boolean_funcs(prop, "rna_Function_no_self_get", NULL);
1394         RNA_def_property_ui_text(prop, "No Self",
1395                                  "Function does not pass its self as an argument (becomes a static method in python)");
1396
1397         prop = RNA_def_property(srna, "use_self_type", PROP_BOOLEAN, PROP_NONE);
1398         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1399         RNA_def_property_boolean_funcs(prop, "rna_Function_use_self_type_get", NULL);
1400         RNA_def_property_ui_text(prop, "Use Self Type",
1401                                  "Function passes its self type as an argument (becomes a class method in python if use_self is false)");
1402 }
1403
1404 static void rna_def_number_property(StructRNA *srna, PropertyType type)
1405 {
1406         PropertyRNA *prop;
1407
1408         prop = RNA_def_property(srna, "default", type, PROP_NONE);
1409         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1410         RNA_def_property_ui_text(prop, "Default", "Default value for this number");
1411
1412         switch (type) {
1413                 case PROP_BOOLEAN:
1414                         RNA_def_property_boolean_funcs(prop, "rna_BoolProperty_default_get", NULL);
1415                         break;
1416                 case PROP_INT:
1417                         RNA_def_property_int_funcs(prop, "rna_IntProperty_default_get", NULL, NULL);
1418                         break;
1419                 case PROP_FLOAT:
1420                         RNA_def_property_float_funcs(prop, "rna_FloatProperty_default_get", NULL, NULL);
1421                         break;
1422                 default:
1423                         break;
1424         }
1425
1426
1427         prop = RNA_def_property(srna, "default_array", type, PROP_NONE);
1428         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1429         RNA_def_property_array(prop, RNA_MAX_ARRAY_DIMENSION); /* no fixed default length, important its not 0 though */
1430         RNA_def_property_flag(prop, PROP_DYNAMIC);
1431         RNA_def_property_dynamic_array_funcs(prop, "rna_NumberProperty_default_array_get_length"); /* same for all types */
1432
1433         switch (type) {
1434                 case PROP_BOOLEAN:
1435                         RNA_def_property_boolean_funcs(prop, "rna_BoolProperty_default_array_get", NULL);
1436                         break;
1437                 case PROP_INT:
1438                         RNA_def_property_int_funcs(prop, "rna_IntProperty_default_array_get", NULL, NULL);
1439                         break;
1440                 case PROP_FLOAT:
1441                         RNA_def_property_float_funcs(prop, "rna_FloatProperty_default_array_get", NULL, NULL);
1442                         break;
1443                 default:
1444                         break;
1445         }
1446         RNA_def_property_ui_text(prop, "Default Array", "Default value for this array");
1447
1448
1449         prop = RNA_def_property(srna, "array_length", PROP_INT, PROP_UNSIGNED);
1450         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1451         RNA_def_property_int_funcs(prop, "rna_Property_array_length_get", NULL, NULL);
1452         RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited");
1453
1454         prop = RNA_def_property(srna, "array_dimensions", PROP_INT, PROP_UNSIGNED);
1455         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1456         RNA_def_property_array(prop, RNA_MAX_ARRAY_DIMENSION);
1457         RNA_def_property_int_funcs(prop, "rna_Property_array_dimensions_get", NULL, NULL);
1458         RNA_def_property_ui_text(prop, "Array Dimensions", "Length of each dimension of the array");
1459
1460         prop = RNA_def_property(srna, "is_array", PROP_BOOLEAN, PROP_NONE);
1461         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1462         RNA_def_property_boolean_funcs(prop, "rna_NumberProperty_is_array_get", NULL);
1463         RNA_def_property_ui_text(prop, "Is Array", "");
1464
1465         if (type == PROP_BOOLEAN)
1466                 return;
1467
1468         prop = RNA_def_property(srna, "hard_min", type, PROP_NONE);
1469         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1470         if (type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_min_get", NULL, NULL);
1471         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_min_get", NULL, NULL);
1472         RNA_def_property_ui_text(prop, "Hard Minimum", "Minimum value used by buttons");
1473
1474         prop = RNA_def_property(srna, "hard_max", type, PROP_NONE);
1475         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1476         if (type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_max_get", NULL, NULL);
1477         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_max_get", NULL, NULL);
1478         RNA_def_property_ui_text(prop, "Hard Maximum", "Maximum value used by buttons");
1479
1480         prop = RNA_def_property(srna, "soft_min", type, PROP_NONE);
1481         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1482         if (type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_min_get", NULL, NULL);
1483         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_min_get", NULL, NULL);
1484         RNA_def_property_ui_text(prop, "Soft Minimum", "Minimum value used by buttons");
1485
1486         prop = RNA_def_property(srna, "soft_max", type, PROP_NONE);
1487         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1488         if (type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_max_get", NULL, NULL);
1489         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_max_get", NULL, NULL);
1490         RNA_def_property_ui_text(prop, "Soft Maximum", "Maximum value used by buttons");
1491
1492         prop = RNA_def_property(srna, "step", type, PROP_UNSIGNED);
1493         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1494         if (type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_step_get", NULL, NULL);
1495         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_step_get", NULL, NULL);
1496         RNA_def_property_ui_text(prop, "Step", "Step size used by number buttons, for floats 1/100th of the step size");
1497
1498         if (type == PROP_FLOAT) {
1499                 prop = RNA_def_property(srna, "precision", PROP_INT, PROP_UNSIGNED);
1500                 RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1501                 RNA_def_property_int_funcs(prop, "rna_FloatProperty_precision_get", NULL, NULL);
1502                 RNA_def_property_ui_text(prop, "Precision", "Number of digits after the dot used by buttons");
1503         }
1504 }
1505
1506 static void rna_def_string_property(StructRNA *srna)
1507 {
1508         PropertyRNA *prop;
1509
1510         prop = RNA_def_property(srna, "default", PROP_STRING, PROP_NONE);
1511         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1512         RNA_def_property_string_funcs(prop, "rna_StringProperty_default_get", "rna_StringProperty_default_length", NULL);
1513         RNA_def_property_ui_text(prop, "Default", "string default value");
1514
1515         prop = RNA_def_property(srna, "length_max", PROP_INT, PROP_UNSIGNED);
1516         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1517         RNA_def_property_int_funcs(prop, "rna_StringProperty_max_length_get", NULL, NULL);
1518         RNA_def_property_ui_text(prop, "Maximum Length", "Maximum length of the string, 0 means unlimited");
1519 }
1520
1521 static void rna_def_enum_property(BlenderRNA *brna, StructRNA *srna)
1522 {
1523         PropertyRNA *prop;
1524
1525         /* the itemf func is used instead, keep blender happy */
1526         static const EnumPropertyItem default_dummy_items[] = {
1527                 {PROP_NONE, "DUMMY", 0, "Dummy", ""},
1528                 {0, NULL, 0, NULL, NULL}
1529         };
1530
1531         prop = RNA_def_property(srna, "default", PROP_ENUM, PROP_NONE);
1532         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1533         RNA_def_property_enum_items(prop, default_dummy_items);
1534         RNA_def_property_enum_funcs(prop, "rna_EnumProperty_default_get", NULL, "rna_EnumProperty_default_itemf");
1535         RNA_def_property_ui_text(prop, "Default", "Default value for this enum");
1536
1537         /* same 'default' but uses 'PROP_ENUM_FLAG' */
1538         prop = RNA_def_property(srna, "default_flag", PROP_ENUM, PROP_NONE);
1539         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1540         RNA_def_property_flag(prop, PROP_ENUM_FLAG);
1541         RNA_def_property_enum_items(prop, default_dummy_items);
1542         RNA_def_property_enum_funcs(prop, "rna_EnumProperty_default_get", NULL, "rna_EnumProperty_default_itemf");
1543         RNA_def_property_ui_text(prop, "Default", "Default value for this enum");
1544
1545         prop = RNA_def_property(srna, "enum_items", PROP_COLLECTION, PROP_NONE);
1546         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1547         RNA_def_property_struct_type(prop, "EnumPropertyItem");
1548         RNA_def_property_collection_funcs(prop, "rna_EnumProperty_items_begin", "rna_iterator_array_next",
1549                                           "rna_iterator_array_end", "rna_iterator_array_get", NULL, NULL, NULL, NULL);
1550         RNA_def_property_ui_text(prop, "Items", "Possible values for the property");
1551
1552         prop = RNA_def_property(srna, "enum_items_static", PROP_COLLECTION, PROP_NONE);
1553         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1554         RNA_def_property_struct_type(prop, "EnumPropertyItem");
1555         RNA_def_property_collection_funcs(prop, "rna_EnumProperty_items_begin", "rna_iterator_array_next",
1556                                           "rna_iterator_array_end", "rna_iterator_array_get", NULL, NULL, NULL, NULL);
1557         RNA_def_property_ui_text(prop, "Static Items",
1558                                  "Possible values for the property (never calls optional dynamic generation of those)");
1559
1560         srna = RNA_def_struct(brna, "EnumPropertyItem", NULL);
1561         RNA_def_struct_ui_text(srna, "Enum Item Definition", "Definition of a choice in an RNA enum property");
1562         RNA_def_struct_ui_icon(srna, ICON_RNA);
1563
1564         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1565         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1566         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_name_get", "rna_EnumPropertyItem_name_length", NULL);
1567         RNA_def_property_ui_text(prop, "Name", "Human readable name");
1568
1569         prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
1570         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1571         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_description_get",
1572                                       "rna_EnumPropertyItem_description_length", NULL);
1573         RNA_def_property_ui_text(prop, "Description", "Description of the item's purpose");
1574
1575         prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
1576         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1577         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_identifier_get",
1578                                       "rna_EnumPropertyItem_identifier_length", NULL);
1579         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
1580         RNA_def_struct_name_property(srna, prop);
1581
1582         prop = RNA_def_property(srna, "value", PROP_INT, PROP_UNSIGNED);
1583         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1584         RNA_def_property_int_funcs(prop, "rna_EnumPropertyItem_value_get", NULL, NULL);
1585         RNA_def_property_ui_text(prop, "Value", "Value of the item");
1586
1587         prop = RNA_def_property(srna, "icon", PROP_ENUM, PROP_NONE);
1588         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1589         RNA_def_property_enum_items(prop, rna_enum_icon_items);
1590         RNA_def_property_enum_funcs(prop, "rna_EnumPropertyItem_icon_get", NULL, NULL);
1591         RNA_def_property_ui_text(prop, "Icon", "Icon of the item");
1592 }
1593
1594 static void rna_def_pointer_property(StructRNA *srna, PropertyType type)
1595 {
1596         PropertyRNA *prop;
1597
1598         prop = RNA_def_property(srna, "fixed_type", PROP_POINTER, PROP_NONE);
1599         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1600         RNA_def_property_struct_type(prop, "Struct");
1601         if (type == PROP_POINTER)
1602                 RNA_def_property_pointer_funcs(prop, "rna_PointerProperty_fixed_type_get", NULL, NULL, NULL);
1603         else
1604                 RNA_def_property_pointer_funcs(prop, "rna_CollectionProperty_fixed_type_get", NULL, NULL, NULL);
1605         RNA_def_property_ui_text(prop, "Pointer Type", "Fixed pointer type, empty if variable type");
1606 }
1607
1608 void RNA_def_rna(BlenderRNA *brna)
1609 {
1610         StructRNA *srna;
1611         PropertyRNA *prop;
1612
1613         /* Struct*/
1614         rna_def_struct(brna);
1615
1616         /* Property */
1617         rna_def_property(brna);
1618
1619         /* BoolProperty */
1620         srna = RNA_def_struct(brna, "BoolProperty", "Property");
1621         RNA_def_struct_ui_text(srna, "Boolean Definition", "RNA boolean property definition");
1622         rna_def_number_property(srna, PROP_BOOLEAN);
1623
1624         /* IntProperty */
1625         srna = RNA_def_struct(brna, "IntProperty", "Property");
1626         RNA_def_struct_ui_text(srna, "Int Definition", "RNA integer number property definition");
1627         rna_def_number_property(srna, PROP_INT);
1628
1629         /* FloatProperty */
1630         srna = RNA_def_struct(brna, "FloatProperty", "Property");
1631         RNA_def_struct_ui_text(srna, "Float Definition", "RNA floating pointer number property definition");
1632         rna_def_number_property(srna, PROP_FLOAT);
1633
1634         /* StringProperty */
1635         srna = RNA_def_struct(brna, "StringProperty", "Property");
1636         RNA_def_struct_ui_text(srna, "String Definition", "RNA text string property definition");
1637         rna_def_string_property(srna);
1638
1639         /* EnumProperty */
1640         srna = RNA_def_struct(brna, "EnumProperty", "Property");
1641         RNA_def_struct_ui_text(srna, "Enum Definition",
1642                                "RNA enumeration property definition, to choose from a number of predefined options");
1643         rna_def_enum_property(brna, srna);
1644
1645         /* PointerProperty */
1646         srna = RNA_def_struct(brna, "PointerProperty", "Property");
1647         RNA_def_struct_ui_text(srna, "Pointer Definition", "RNA pointer property to point to another RNA struct");
1648         rna_def_pointer_property(srna, PROP_POINTER);
1649
1650         /* CollectionProperty */
1651         srna = RNA_def_struct(brna, "CollectionProperty", "Property");
1652         RNA_def_struct_ui_text(srna, "Collection Definition",
1653                                "RNA collection property to define lists, arrays and mappings");
1654         rna_def_pointer_property(srna, PROP_COLLECTION);
1655
1656         /* Function */
1657         rna_def_function(brna);
1658
1659         /* Blender RNA */
1660         srna = RNA_def_struct(brna, "BlenderRNA", NULL);
1661         RNA_def_struct_ui_text(srna, "Blender RNA", "Blender RNA structure definitions");
1662         RNA_def_struct_ui_icon(srna, ICON_RNA);
1663
1664         prop = RNA_def_property(srna, "structs", PROP_COLLECTION, PROP_NONE);
1665         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1666         RNA_def_property_struct_type(prop, "Struct");
1667         RNA_def_property_collection_funcs(prop, "rna_BlenderRNA_structs_begin", "rna_iterator_listbase_next",
1668                                           "rna_iterator_listbase_end", "rna_iterator_listbase_get",
1669                                           /* included for speed, can be removed */
1670 #if 0
1671                                           NULL, NULL, NULL, NULL);
1672 #else
1673                                           "rna_BlenderRNA_structs_length", "rna_BlenderRNA_structs_lookup_int",
1674                                           "rna_BlenderRNA_structs_lookup_string", NULL);
1675 #endif
1676
1677         RNA_def_property_ui_text(prop, "Structs", "");
1678 }
1679
1680 #endif