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