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