Expose multi-dimensional array data in properties' introspection data.
[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 void rna_Property_array_dimensions_get(PointerRNA *ptr, int dimensions[RNA_MAX_ARRAY_DIMENSION])
614 {
615         PropertyRNA *prop = (PropertyRNA *)ptr->data;
616         rna_idproperty_check(&prop, ptr);
617
618         if (prop->arraydimension > 1) {
619                 for (int i = RNA_MAX_ARRAY_DIMENSION; i--; ) {
620                         dimensions[i] = (i >= prop->arraydimension) ? 0 : prop->arraylength[i];
621                 }
622         }
623         else {
624                 memset(dimensions, 0, sizeof(*dimensions) * RNA_MAX_ARRAY_DIMENSION);
625                 dimensions[0] = prop->totarraylength;
626         }
627 }
628
629 static int rna_Property_is_registered_get(PointerRNA *ptr)
630 {
631         PropertyRNA *prop = (PropertyRNA *)ptr->data;
632         return (prop->flag & PROP_REGISTER) != 0;
633 }
634
635 static int rna_Property_is_registered_optional_get(PointerRNA *ptr)
636 {
637         PropertyRNA *prop = (PropertyRNA *)ptr->data;
638         return (prop->flag & PROP_REGISTER_OPTIONAL) != 0;
639 }
640
641 static int rna_Property_is_runtime_get(PointerRNA *ptr)
642 {
643         PropertyRNA *prop = (PropertyRNA *)ptr->data;
644         return (prop->flag_internal & PROP_INTERN_RUNTIME) != 0;
645 }
646
647
648 static int rna_BoolProperty_default_get(PointerRNA *ptr)
649 {
650         PropertyRNA *prop = (PropertyRNA *)ptr->data;
651         rna_idproperty_check(&prop, ptr);
652         return ((BoolPropertyRNA *)prop)->defaultvalue;
653 }
654
655 static int rna_IntProperty_default_get(PointerRNA *ptr)
656 {
657         PropertyRNA *prop = (PropertyRNA *)ptr->data;
658         rna_idproperty_check(&prop, ptr);
659         return ((IntPropertyRNA *)prop)->defaultvalue;
660 }
661 /* int/float/bool */
662 static int rna_NumberProperty_default_array_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
663 {
664         PropertyRNA *prop = (PropertyRNA *)ptr->data;
665         rna_idproperty_check(&prop, ptr);
666
667         length[0] = prop->totarraylength;
668
669         return length[0];
670 }
671 static int rna_NumberProperty_is_array_get(PointerRNA *ptr)
672 {
673         PropertyRNA *prop = (PropertyRNA *)ptr->data;
674
675         return RNA_property_array_check(prop);
676 }
677
678 static void rna_IntProperty_default_array_get(PointerRNA *ptr, int *values)
679 {
680         PropertyRNA *prop = (PropertyRNA *)ptr->data;
681         IntPropertyRNA *nprop = (IntPropertyRNA *)prop;
682         rna_idproperty_check(&prop, ptr);
683
684         if (nprop->defaultarray) {
685                 memcpy(values, nprop->defaultarray, prop->totarraylength * sizeof(int));
686         }
687         else {
688                 int i;
689                 for (i = 0; i < prop->totarraylength; i++)
690                         values[i] = nprop->defaultvalue;
691         }
692 }
693 static void rna_BoolProperty_default_array_get(PointerRNA *ptr, int *values)
694 {
695         PropertyRNA *prop = (PropertyRNA *)ptr->data;
696         BoolPropertyRNA *nprop = (BoolPropertyRNA *)prop;
697         rna_idproperty_check(&prop, ptr);
698
699         if (nprop->defaultarray) {
700                 memcpy(values, nprop->defaultarray, prop->totarraylength * sizeof(int));
701         }
702         else {
703                 int i;
704                 for (i = 0; i < prop->totarraylength; i++)
705                         values[i] = nprop->defaultvalue;
706         }
707 }
708 static void rna_FloatProperty_default_array_get(PointerRNA *ptr, float *values)
709 {
710         PropertyRNA *prop = (PropertyRNA *)ptr->data;
711         FloatPropertyRNA *nprop = (FloatPropertyRNA *)prop;
712         rna_idproperty_check(&prop, ptr);
713
714         if (nprop->defaultarray) {
715                 memcpy(values, nprop->defaultarray, prop->totarraylength * sizeof(float));
716         }
717         else {
718                 int i;
719                 for (i = 0; i < prop->totarraylength; i++)
720                         values[i] = nprop->defaultvalue;
721         }
722 }
723
724 static int rna_IntProperty_hard_min_get(PointerRNA *ptr)
725 {
726         PropertyRNA *prop = (PropertyRNA *)ptr->data;
727         rna_idproperty_check(&prop, ptr);
728         return ((IntPropertyRNA *)prop)->hardmin;
729 }
730
731 static int rna_IntProperty_hard_max_get(PointerRNA *ptr)
732 {
733         PropertyRNA *prop = (PropertyRNA *)ptr->data;
734         rna_idproperty_check(&prop, ptr);
735         return ((IntPropertyRNA *)prop)->hardmax;
736 }
737
738 static int rna_IntProperty_soft_min_get(PointerRNA *ptr)
739 {
740         PropertyRNA *prop = (PropertyRNA *)ptr->data;
741         rna_idproperty_check(&prop, ptr);
742         return ((IntPropertyRNA *)prop)->softmin;
743 }
744
745 static int rna_IntProperty_soft_max_get(PointerRNA *ptr)
746 {
747         PropertyRNA *prop = (PropertyRNA *)ptr->data;
748         rna_idproperty_check(&prop, ptr);
749         return ((IntPropertyRNA *)prop)->softmax;
750 }
751
752 static int rna_IntProperty_step_get(PointerRNA *ptr)
753 {
754         PropertyRNA *prop = (PropertyRNA *)ptr->data;
755         rna_idproperty_check(&prop, ptr);
756         return ((IntPropertyRNA *)prop)->step;
757 }
758
759 static float rna_FloatProperty_default_get(PointerRNA *ptr)
760 {
761         PropertyRNA *prop = (PropertyRNA *)ptr->data;
762         rna_idproperty_check(&prop, ptr);
763         return ((FloatPropertyRNA *)prop)->defaultvalue;
764 }
765 static float rna_FloatProperty_hard_min_get(PointerRNA *ptr)
766 {
767         PropertyRNA *prop = (PropertyRNA *)ptr->data;
768         rna_idproperty_check(&prop, ptr);
769         return ((FloatPropertyRNA *)prop)->hardmin;
770 }
771
772 static float rna_FloatProperty_hard_max_get(PointerRNA *ptr)
773 {
774         PropertyRNA *prop = (PropertyRNA *)ptr->data;
775         rna_idproperty_check(&prop, ptr);
776         return ((FloatPropertyRNA *)prop)->hardmax;
777 }
778
779 static float rna_FloatProperty_soft_min_get(PointerRNA *ptr)
780 {
781         PropertyRNA *prop = (PropertyRNA *)ptr->data;
782         rna_idproperty_check(&prop, ptr);
783         return ((FloatPropertyRNA *)prop)->softmin;
784 }
785
786 static float rna_FloatProperty_soft_max_get(PointerRNA *ptr)
787 {
788         PropertyRNA *prop = (PropertyRNA *)ptr->data;
789         rna_idproperty_check(&prop, ptr);
790         return ((FloatPropertyRNA *)prop)->softmax;
791 }
792
793 static float rna_FloatProperty_step_get(PointerRNA *ptr)
794 {
795         PropertyRNA *prop = (PropertyRNA *)ptr->data;
796         rna_idproperty_check(&prop, ptr);
797         return ((FloatPropertyRNA *)prop)->step;
798 }
799
800 static int rna_FloatProperty_precision_get(PointerRNA *ptr)
801 {
802         PropertyRNA *prop = (PropertyRNA *)ptr->data;
803         rna_idproperty_check(&prop, ptr);
804         return ((FloatPropertyRNA *)prop)->precision;
805 }
806
807 static void rna_StringProperty_default_get(PointerRNA *ptr, char *value)
808 {
809         PropertyRNA *prop = (PropertyRNA *)ptr->data;
810         rna_idproperty_check(&prop, ptr);
811         strcpy(value, ((StringPropertyRNA *)prop)->defaultvalue);
812 }
813 static int rna_StringProperty_default_length(PointerRNA *ptr)
814 {
815         PropertyRNA *prop = (PropertyRNA *)ptr->data;
816         rna_idproperty_check(&prop, ptr);
817         return strlen(((StringPropertyRNA *)prop)->defaultvalue);
818 }
819
820 static int rna_StringProperty_max_length_get(PointerRNA *ptr)
821 {
822         PropertyRNA *prop = (PropertyRNA *)ptr->data;
823         rna_idproperty_check(&prop, ptr);
824         return ((StringPropertyRNA *)prop)->maxlength;
825 }
826
827 static EnumPropertyItem *rna_EnumProperty_default_itemf(bContext *C, PointerRNA *ptr,
828                                                         PropertyRNA *prop_parent, bool *r_free)
829 {
830         PropertyRNA *prop = (PropertyRNA *)ptr->data;
831         EnumPropertyRNA *eprop;
832
833         rna_idproperty_check(&prop, ptr);
834         eprop = (EnumPropertyRNA *)prop;
835
836         /* incompatible default attributes */
837         if ((prop_parent->flag & PROP_ENUM_FLAG) != (prop->flag & PROP_ENUM_FLAG)) {
838                 return DummyRNA_NULL_items;
839         }
840
841         if ((eprop->itemf == NULL) ||
842             (eprop->itemf == rna_EnumProperty_default_itemf) ||
843             (ptr->type == &RNA_EnumProperty) ||
844             (C == NULL))
845         {
846                 if (eprop->item) {
847                         return eprop->item;
848                 }
849         }
850
851         return eprop->itemf(C, ptr, prop, r_free);
852 }
853
854 /* XXX - not sure this is needed? */
855 static int rna_EnumProperty_default_get(PointerRNA *ptr)
856 {
857         PropertyRNA *prop = (PropertyRNA *)ptr->data;
858         rna_idproperty_check(&prop, ptr);
859         return ((EnumPropertyRNA *)prop)->defaultvalue;
860 }
861
862 static int rna_enum_check_separator(CollectionPropertyIterator *UNUSED(iter), void *data)
863 {
864         EnumPropertyItem *item = (EnumPropertyItem *)data;
865
866         return (item->identifier[0] == 0);
867 }
868
869 static void rna_EnumProperty_items_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
870 {
871         PropertyRNA *prop = (PropertyRNA *)ptr->data;
872         /* EnumPropertyRNA *eprop;  *//* UNUSED */
873         EnumPropertyItem *item = NULL;
874         int totitem;
875         bool free;
876         
877         rna_idproperty_check(&prop, ptr);
878         /* eprop = (EnumPropertyRNA *)prop; */
879         
880         RNA_property_enum_items_ex(
881                     NULL, ptr, prop, STREQ(iter->prop->identifier, "enum_items_static"), &item, &totitem, &free);
882         rna_iterator_array_begin(iter, (void *)item, sizeof(EnumPropertyItem), totitem, free, rna_enum_check_separator);
883 }
884
885 static void rna_EnumPropertyItem_identifier_get(PointerRNA *ptr, char *value)
886 {
887         strcpy(value, ((EnumPropertyItem *)ptr->data)->identifier);
888 }
889
890 static int rna_EnumPropertyItem_identifier_length(PointerRNA *ptr)
891 {
892         return strlen(((EnumPropertyItem *)ptr->data)->identifier);
893 }
894
895 static void rna_EnumPropertyItem_name_get(PointerRNA *ptr, char *value)
896 {
897         strcpy(value, ((EnumPropertyItem *)ptr->data)->name);
898 }
899
900 static int rna_EnumPropertyItem_name_length(PointerRNA *ptr)
901 {
902         return strlen(((EnumPropertyItem *)ptr->data)->name);
903 }
904
905 static void rna_EnumPropertyItem_description_get(PointerRNA *ptr, char *value)
906 {
907         EnumPropertyItem *eprop = (EnumPropertyItem *)ptr->data;
908
909         if (eprop->description)
910                 strcpy(value, eprop->description);
911         else
912                 value[0] = '\0';
913 }
914
915 static int rna_EnumPropertyItem_description_length(PointerRNA *ptr)
916 {
917         EnumPropertyItem *eprop = (EnumPropertyItem *)ptr->data;
918
919         if (eprop->description)
920                 return strlen(eprop->description);
921         else
922                 return 0;
923 }
924
925 static int rna_EnumPropertyItem_value_get(PointerRNA *ptr)
926 {
927         return ((EnumPropertyItem *)ptr->data)->value;
928 }
929
930 static int rna_EnumPropertyItem_icon_get(PointerRNA *ptr)
931 {
932         return ((EnumPropertyItem *)ptr->data)->icon;
933 }
934
935 static PointerRNA rna_PointerProperty_fixed_type_get(PointerRNA *ptr)
936 {
937         PropertyRNA *prop = (PropertyRNA *)ptr->data;
938         rna_idproperty_check(&prop, ptr);
939         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((PointerPropertyRNA *)prop)->type);
940 }
941
942 static PointerRNA rna_CollectionProperty_fixed_type_get(PointerRNA *ptr)
943 {
944         PropertyRNA *prop = (PropertyRNA *)ptr->data;
945         rna_idproperty_check(&prop, ptr);
946         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((CollectionPropertyRNA *)prop)->item_type);
947 }
948
949 /* Function */
950
951 static void rna_Function_identifier_get(PointerRNA *ptr, char *value)
952 {
953         strcpy(value, ((FunctionRNA *)ptr->data)->identifier);
954 }
955
956 static int rna_Function_identifier_length(PointerRNA *ptr)
957 {
958         return strlen(((FunctionRNA *)ptr->data)->identifier);
959 }
960
961 static void rna_Function_description_get(PointerRNA *ptr, char *value)
962 {
963         strcpy(value, ((FunctionRNA *)ptr->data)->description);
964 }
965
966 static int rna_Function_description_length(PointerRNA *ptr)
967 {
968         return strlen(((FunctionRNA *)ptr->data)->description);
969 }
970
971 static void rna_Function_parameters_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
972 {
973         rna_iterator_listbase_begin(iter, &((FunctionRNA *)ptr->data)->cont.properties, rna_property_builtin);
974 }
975
976 static int rna_Function_registered_get(PointerRNA *ptr)
977 {
978         FunctionRNA *func = (FunctionRNA *)ptr->data;
979         return 0 != (func->flag & FUNC_REGISTER);
980 }
981
982 static int rna_Function_registered_optional_get(PointerRNA *ptr)
983 {
984         FunctionRNA *func = (FunctionRNA *)ptr->data;
985         return 0 != (func->flag & (FUNC_REGISTER_OPTIONAL & ~FUNC_REGISTER));
986 }
987
988 static int rna_Function_no_self_get(PointerRNA *ptr)
989 {
990         FunctionRNA *func = (FunctionRNA *)ptr->data;
991         return !(func->flag & FUNC_NO_SELF);
992 }
993
994 static int rna_Function_use_self_type_get(PointerRNA *ptr)
995 {
996         FunctionRNA *func = (FunctionRNA *)ptr->data;
997         return 0 != (func->flag & FUNC_USE_SELF_TYPE);
998 }
999
1000 /* Blender RNA */
1001
1002 static int rna_struct_is_publc(CollectionPropertyIterator *UNUSED(iter), void *data)
1003 {
1004         StructRNA *srna = data;
1005
1006         return !(srna->flag & STRUCT_PUBLIC_NAMESPACE);
1007 }
1008
1009
1010 static void rna_BlenderRNA_structs_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
1011 {
1012         BlenderRNA *brna = ptr->data;
1013         rna_iterator_listbase_begin(iter, &brna->structs, rna_struct_is_publc);
1014 }
1015
1016 /* optional, for faster lookups */
1017 static int rna_BlenderRNA_structs_length(PointerRNA *ptr)
1018 {
1019         BlenderRNA *brna = ptr->data;
1020         BLI_assert(brna->structs_len == BLI_listbase_count(&brna->structs));
1021         return brna->structs_len;
1022 }
1023 static int rna_BlenderRNA_structs_lookup_int(PointerRNA *ptr, int index, PointerRNA *r_ptr)
1024 {
1025         BlenderRNA *brna = ptr->data;
1026         StructRNA *srna = index < brna->structs_len ? BLI_findlink(&brna->structs, index) : NULL;
1027         if (srna != NULL) {
1028                 RNA_pointer_create(NULL, &RNA_Struct, srna, r_ptr);
1029                 return true;
1030         }
1031         else {
1032                 return false;
1033         }
1034 }
1035 static int rna_BlenderRNA_structs_lookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
1036 {
1037         BlenderRNA *brna = ptr->data;
1038         StructRNA *srna = BLI_ghash_lookup(brna->structs_map, (void *)key);
1039         if (srna != NULL) {
1040                 RNA_pointer_create(NULL, &RNA_Struct, srna, r_ptr);
1041                 return true;
1042         }
1043
1044         return false;
1045 }
1046
1047
1048 #else
1049
1050 static void rna_def_struct(BlenderRNA *brna)
1051 {
1052         StructRNA *srna;
1053         PropertyRNA *prop;
1054
1055         srna = RNA_def_struct(brna, "Struct", NULL);
1056         RNA_def_struct_ui_text(srna, "Struct Definition", "RNA structure definition");
1057         RNA_def_struct_ui_icon(srna, ICON_RNA);
1058
1059         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1060         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1061         RNA_def_property_string_funcs(prop, "rna_Struct_name_get", "rna_Struct_name_length", NULL);
1062         RNA_def_property_ui_text(prop, "Name", "Human readable name");
1063
1064         prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
1065         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1066         RNA_def_property_string_funcs(prop, "rna_Struct_identifier_get", "rna_Struct_identifier_length", NULL);
1067         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
1068         RNA_def_struct_name_property(srna, prop);
1069         
1070         prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
1071         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1072         RNA_def_property_string_funcs(prop, "rna_Struct_description_get", "rna_Struct_description_length", NULL);
1073         RNA_def_property_ui_text(prop, "Description", "Description of the Struct's purpose");
1074         
1075         prop = RNA_def_property(srna, "translation_context", PROP_STRING, PROP_NONE);
1076         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1077         RNA_def_property_string_funcs(prop, "rna_Struct_translation_context_get",
1078                                       "rna_Struct_translation_context_length", NULL);
1079         RNA_def_property_ui_text(prop, "Translation Context", "Translation context of the struct's name");
1080         
1081         prop = RNA_def_property(srna, "base", PROP_POINTER, PROP_NONE);
1082         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1083         RNA_def_property_struct_type(prop, "Struct");
1084         RNA_def_property_pointer_funcs(prop, "rna_Struct_base_get", NULL, NULL, NULL);
1085         RNA_def_property_ui_text(prop, "Base", "Struct definition this is derived from");
1086
1087         prop = RNA_def_property(srna, "nested", PROP_POINTER, PROP_NONE);
1088         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1089         RNA_def_property_struct_type(prop, "Struct");
1090         RNA_def_property_pointer_funcs(prop, "rna_Struct_nested_get", NULL, NULL, NULL);
1091         RNA_def_property_ui_text(prop, "Nested",
1092                                  "Struct in which this struct is always nested, and to which it logically belongs");
1093
1094         prop = RNA_def_property(srna, "name_property", PROP_POINTER, PROP_NONE);
1095         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1096         RNA_def_property_struct_type(prop, "StringProperty");
1097         RNA_def_property_pointer_funcs(prop, "rna_Struct_name_property_get", NULL, NULL, NULL);
1098         RNA_def_property_ui_text(prop, "Name Property", "Property that gives the name of the struct");
1099
1100         prop = RNA_def_property(srna, "properties", PROP_COLLECTION, PROP_NONE);
1101         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1102         RNA_def_property_struct_type(prop, "Property");
1103         RNA_def_property_collection_funcs(prop, "rna_Struct_properties_begin", "rna_Struct_properties_next",
1104                                           "rna_iterator_listbase_end", "rna_Struct_properties_get",
1105                                           NULL, NULL, NULL, NULL);
1106         RNA_def_property_ui_text(prop, "Properties", "Properties in the struct");
1107
1108         prop = RNA_def_property(srna, "functions", PROP_COLLECTION, PROP_NONE);
1109         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1110         RNA_def_property_struct_type(prop, "Function");
1111         RNA_def_property_collection_funcs(prop, "rna_Struct_functions_begin", "rna_Struct_functions_next",
1112                                           "rna_iterator_listbase_end", "rna_Struct_functions_get",
1113                                           NULL, NULL, NULL, NULL);
1114         RNA_def_property_ui_text(prop, "Functions", "");
1115 }
1116
1117 static void rna_def_property(BlenderRNA *brna)
1118 {
1119         StructRNA *srna;
1120         PropertyRNA *prop;
1121         static EnumPropertyItem subtype_items[] = {
1122                 {PROP_NONE, "NONE", 0, "None", ""},
1123                 {PROP_FILEPATH, "FILE_PATH", 0, "File Path", ""},
1124                 {PROP_DIRPATH, "DIR_PATH", 0, "Directory Path", ""},
1125                 {PROP_PIXEL, "PIXEL", 0, "Pixel", ""},
1126                 {PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned Number", ""},
1127                 {PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", ""},
1128                 {PROP_FACTOR, "FACTOR", 0, "Factor", ""},
1129                 {PROP_ANGLE, "ANGLE", 0, "Angle", ""},
1130                 {PROP_TIME, "TIME", 0, "Time", ""},
1131                 {PROP_DISTANCE, "DISTANCE", 0, "Distance", ""},
1132                 {PROP_COLOR, "COLOR", 0, "Color", ""},
1133                 {PROP_TRANSLATION, "TRANSLATION", 0, "Translation", ""},
1134                 {PROP_DIRECTION, "DIRECTION", 0, "Direction", ""},
1135                 {PROP_MATRIX, "MATRIX", 0, "Matrix", ""},
1136                 {PROP_EULER, "EULER", 0, "Euler", ""},
1137                 {PROP_QUATERNION, "QUATERNION", 0, "Quaternion", ""},
1138                 {PROP_XYZ, "XYZ", 0, "XYZ", ""},
1139                 {PROP_COLOR_GAMMA, "COLOR_GAMMA", 0, "Gamma Corrected Color", ""},
1140                 {PROP_COORDS, "COORDINATES", 0, "Vector Coordinates", ""},
1141                 {PROP_LAYER, "LAYER", 0, "Layer", ""},
1142                 {PROP_LAYER_MEMBER, "LAYER_MEMBERSHIP", 0, "Layer Membership", ""},
1143                 {0, NULL, 0, NULL, NULL}
1144         };
1145
1146         srna = RNA_def_struct(brna, "Property", NULL);
1147         RNA_def_struct_ui_text(srna, "Property Definition", "RNA property definition");
1148         RNA_def_struct_refine_func(srna, "rna_Property_refine");
1149         RNA_def_struct_ui_icon(srna, ICON_RNA);
1150
1151         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1152         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1153         RNA_def_property_string_funcs(prop, "rna_Property_name_get", "rna_Property_name_length", NULL);
1154         RNA_def_property_ui_text(prop, "Name", "Human readable name");
1155
1156         prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
1157         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1158         RNA_def_property_string_funcs(prop, "rna_Property_identifier_get", "rna_Property_identifier_length", NULL);
1159         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
1160         RNA_def_struct_name_property(srna, prop);
1161                 
1162         prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
1163         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1164         RNA_def_property_string_funcs(prop, "rna_Property_description_get", "rna_Property_description_length", NULL);
1165         RNA_def_property_ui_text(prop, "Description", "Description of the property for tooltips");
1166
1167         prop = RNA_def_property(srna, "translation_context", PROP_STRING, PROP_NONE);
1168         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1169         RNA_def_property_string_funcs(prop, "rna_Property_translation_context_get",
1170                                       "rna_Property_translation_context_length", NULL);
1171         RNA_def_property_ui_text(prop, "Translation Context", "Translation context of the property's name");
1172
1173         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1174         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1175         RNA_def_property_enum_items(prop, rna_enum_property_type_items);
1176         RNA_def_property_enum_funcs(prop, "rna_Property_type_get", NULL, NULL);
1177         RNA_def_property_ui_text(prop, "Type", "Data type of the property");
1178
1179         prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
1180         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1181         RNA_def_property_enum_items(prop, subtype_items);
1182         RNA_def_property_enum_funcs(prop, "rna_Property_subtype_get", NULL, NULL);
1183         RNA_def_property_ui_text(prop, "Subtype", "Semantic interpretation of the property");
1184
1185         prop = RNA_def_property(srna, "srna", PROP_POINTER, PROP_NONE);
1186         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1187         RNA_def_property_struct_type(prop, "Struct");
1188         RNA_def_property_pointer_funcs(prop, "rna_Property_srna_get", NULL, NULL, NULL);
1189         RNA_def_property_ui_text(prop, "Base", "Struct definition used for properties assigned to this item");
1190
1191         prop = RNA_def_property(srna, "unit", PROP_ENUM, PROP_NONE);
1192         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1193         RNA_def_property_enum_items(prop, rna_enum_property_unit_items);
1194         RNA_def_property_enum_funcs(prop, "rna_Property_unit_get", NULL, NULL);
1195         RNA_def_property_ui_text(prop, "Unit", "Type of units for this property");
1196
1197         prop = RNA_def_property(srna, "icon", PROP_ENUM, PROP_NONE);
1198         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1199         RNA_def_property_enum_items(prop, rna_enum_icon_items);
1200         RNA_def_property_enum_funcs(prop, "rna_Property_icon_get", NULL, NULL);
1201         RNA_def_property_ui_text(prop, "Icon", "Icon of the item");
1202
1203         prop = RNA_def_property(srna, "is_readonly", PROP_BOOLEAN, PROP_NONE);
1204         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1205         RNA_def_property_boolean_funcs(prop, "rna_Property_readonly_get", NULL);
1206         RNA_def_property_ui_text(prop, "Read Only", "Property is editable through RNA");
1207
1208         prop = RNA_def_property(srna, "is_animatable", PROP_BOOLEAN, PROP_NONE);
1209         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1210         RNA_def_property_boolean_funcs(prop, "rna_Property_animatable_get", NULL);
1211         RNA_def_property_ui_text(prop, "Animatable", "Property is animatable through RNA");
1212
1213         prop = RNA_def_property(srna, "is_required", PROP_BOOLEAN, PROP_NONE);
1214         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1215         RNA_def_property_boolean_funcs(prop, "rna_Property_is_required_get", NULL);
1216         RNA_def_property_ui_text(prop, "Required", "False when this property is an optional argument in an RNA function");
1217
1218         prop = RNA_def_property(srna, "is_argument_optional", PROP_BOOLEAN, PROP_NONE);
1219         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1220         RNA_def_property_boolean_funcs(prop, "rna_Property_is_argument_optional_get", NULL);
1221         RNA_def_property_ui_text(prop, "Optional Argument",
1222                                  "True when the property is optional in a Python function implementing an RNA function");
1223
1224         prop = RNA_def_property(srna, "is_never_none", PROP_BOOLEAN, PROP_NONE);
1225         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1226         RNA_def_property_boolean_funcs(prop, "rna_Property_is_never_none_get", NULL);
1227         RNA_def_property_ui_text(prop, "Never None", "True when this value can't be set to None");
1228
1229         prop = RNA_def_property(srna, "is_hidden", PROP_BOOLEAN, PROP_NONE);
1230         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1231         RNA_def_property_boolean_funcs(prop, "rna_Property_is_hidden_get", NULL);
1232         RNA_def_property_ui_text(prop, "Hidden", "True when the property is hidden");
1233
1234         prop = RNA_def_property(srna, "is_skip_save", PROP_BOOLEAN, PROP_NONE);
1235         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1236         RNA_def_property_boolean_funcs(prop, "rna_Property_is_skip_save_get", NULL);
1237         RNA_def_property_ui_text(prop, "Skip Save", "True when the property is not saved in presets");
1238
1239         prop = RNA_def_property(srna, "is_output", PROP_BOOLEAN, PROP_NONE);
1240         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1241         RNA_def_property_boolean_funcs(prop, "rna_Property_use_output_get", NULL);
1242         RNA_def_property_ui_text(prop, "Return", "True when this property is an output value from an RNA function");
1243
1244         prop = RNA_def_property(srna, "is_registered", PROP_BOOLEAN, PROP_NONE);
1245         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1246         RNA_def_property_boolean_funcs(prop, "rna_Property_is_registered_get", NULL);
1247         RNA_def_property_ui_text(prop, "Registered", "Property is registered as part of type registration");
1248
1249         prop = RNA_def_property(srna, "is_registered_optional", PROP_BOOLEAN, PROP_NONE);
1250         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1251         RNA_def_property_boolean_funcs(prop, "rna_Property_is_registered_optional_get", NULL);
1252         RNA_def_property_ui_text(prop, "Registered Optionally",
1253                                  "Property is optionally registered as part of type registration");
1254         
1255         prop = RNA_def_property(srna, "is_runtime", PROP_BOOLEAN, PROP_NONE);
1256         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1257         RNA_def_property_boolean_funcs(prop, "rna_Property_is_runtime_get", NULL);
1258         RNA_def_property_ui_text(prop, "Runtime", "Property has been dynamically created at runtime");
1259
1260         prop = RNA_def_property(srna, "is_enum_flag", PROP_BOOLEAN, PROP_NONE);
1261         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1262         RNA_def_property_boolean_funcs(prop, "rna_Property_is_enum_flag_get", NULL);
1263         RNA_def_property_ui_text(prop, "Enum Flag", "True when multiple enums ");
1264
1265         prop = RNA_def_property(srna, "is_library_editable", PROP_BOOLEAN, PROP_NONE);
1266         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1267         RNA_def_property_boolean_funcs(prop, "rna_Property_is_library_editable_flag_get", NULL);
1268         RNA_def_property_ui_text(prop, "Library Editable", "Property is editable from linked instances (changes not saved)");
1269 }
1270
1271 static void rna_def_function(BlenderRNA *brna)
1272 {
1273         StructRNA *srna;
1274         PropertyRNA *prop;
1275
1276         srna = RNA_def_struct(brna, "Function", NULL);
1277         RNA_def_struct_ui_text(srna, "Function Definition", "RNA function definition");
1278         RNA_def_struct_ui_icon(srna, ICON_RNA);
1279
1280         prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
1281         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1282         RNA_def_property_string_funcs(prop, "rna_Function_identifier_get", "rna_Function_identifier_length", NULL);
1283         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
1284         RNA_def_struct_name_property(srna, prop);
1285
1286         prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
1287         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1288         RNA_def_property_string_funcs(prop, "rna_Function_description_get", "rna_Function_description_length", NULL);
1289         RNA_def_property_ui_text(prop, "Description", "Description of the Function's purpose");
1290
1291         prop = RNA_def_property(srna, "parameters", PROP_COLLECTION, PROP_NONE);
1292         /*RNA_def_property_clear_flag(prop, PROP_EDITABLE);*/
1293         RNA_def_property_struct_type(prop, "Property");
1294         RNA_def_property_collection_funcs(prop, "rna_Function_parameters_begin", "rna_iterator_listbase_next",
1295                                           "rna_iterator_listbase_end", "rna_iterator_listbase_get",
1296                                           NULL, NULL, NULL, NULL);
1297         RNA_def_property_ui_text(prop, "Parameters", "Parameters for the function");
1298
1299         prop = RNA_def_property(srna, "is_registered", PROP_BOOLEAN, PROP_NONE);
1300         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1301         RNA_def_property_boolean_funcs(prop, "rna_Function_registered_get", NULL);
1302         RNA_def_property_ui_text(prop, "Registered", "Function is registered as callback as part of type registration");
1303
1304         prop = RNA_def_property(srna, "is_registered_optional", PROP_BOOLEAN, PROP_NONE);
1305         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1306         RNA_def_property_boolean_funcs(prop, "rna_Function_registered_optional_get", NULL);
1307         RNA_def_property_ui_text(prop, "Registered Optionally",
1308                                  "Function is optionally registered as callback part of type registration");
1309
1310         prop = RNA_def_property(srna, "use_self", PROP_BOOLEAN, PROP_NONE);
1311         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1312         RNA_def_property_boolean_funcs(prop, "rna_Function_no_self_get", NULL);
1313         RNA_def_property_ui_text(prop, "No Self",
1314                                  "Function does not pass its self as an argument (becomes a static method in python)");
1315         
1316         prop = RNA_def_property(srna, "use_self_type", PROP_BOOLEAN, PROP_NONE);
1317         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1318         RNA_def_property_boolean_funcs(prop, "rna_Function_use_self_type_get", NULL);
1319         RNA_def_property_ui_text(prop, "Use Self Type",
1320                                  "Function passes its self type as an argument (becomes a class method in python if use_self is false)");
1321 }
1322
1323 static void rna_def_number_property(StructRNA *srna, PropertyType type)
1324 {
1325         PropertyRNA *prop;
1326
1327         prop = RNA_def_property(srna, "default", type, PROP_NONE);
1328         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1329         RNA_def_property_ui_text(prop, "Default", "Default value for this number");
1330
1331         switch (type) {
1332                 case PROP_BOOLEAN:
1333                         RNA_def_property_boolean_funcs(prop, "rna_BoolProperty_default_get", NULL);
1334                         break;
1335                 case PROP_INT:
1336                         RNA_def_property_int_funcs(prop, "rna_IntProperty_default_get", NULL, NULL);
1337                         break;
1338                 case PROP_FLOAT:
1339                         RNA_def_property_float_funcs(prop, "rna_FloatProperty_default_get", NULL, NULL);
1340                         break;
1341                 default:
1342                         break;
1343         }
1344
1345
1346         prop = RNA_def_property(srna, "default_array", type, PROP_NONE);
1347         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1348         RNA_def_property_array(prop, RNA_MAX_ARRAY_DIMENSION); /* no fixed default length, important its not 0 though */
1349         RNA_def_property_flag(prop, PROP_DYNAMIC);
1350         RNA_def_property_dynamic_array_funcs(prop, "rna_NumberProperty_default_array_get_length"); /* same for all types */
1351
1352         switch (type) {
1353                 case PROP_BOOLEAN:
1354                         RNA_def_property_boolean_funcs(prop, "rna_BoolProperty_default_array_get", NULL);
1355                         break;
1356                 case PROP_INT:
1357                         RNA_def_property_int_funcs(prop, "rna_IntProperty_default_array_get", NULL, NULL);
1358                         break;
1359                 case PROP_FLOAT:
1360                         RNA_def_property_float_funcs(prop, "rna_FloatProperty_default_array_get", NULL, NULL);
1361                         break;
1362                 default:
1363                         break;
1364         }
1365         RNA_def_property_ui_text(prop, "Default Array", "Default value for this array");
1366
1367
1368         prop = RNA_def_property(srna, "array_length", PROP_INT, PROP_UNSIGNED);
1369         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1370         RNA_def_property_int_funcs(prop, "rna_Property_array_length_get", NULL, NULL);
1371         RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited");
1372
1373         prop = RNA_def_property(srna, "array_dimensions", PROP_INT, PROP_UNSIGNED);
1374         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1375         RNA_def_property_array(prop, RNA_MAX_ARRAY_DIMENSION);
1376         RNA_def_property_int_funcs(prop, "rna_Property_array_dimensions_get", NULL, NULL);
1377         RNA_def_property_ui_text(prop, "Array Dimensions", "Length of each dimension of the array");
1378
1379         prop = RNA_def_property(srna, "is_array", PROP_BOOLEAN, PROP_NONE);
1380         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1381         RNA_def_property_boolean_funcs(prop, "rna_NumberProperty_is_array_get", NULL);
1382         RNA_def_property_ui_text(prop, "Is Array", "");
1383
1384         if (type == PROP_BOOLEAN)
1385                 return;
1386
1387         prop = RNA_def_property(srna, "hard_min", type, PROP_NONE);
1388         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1389         if (type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_min_get", NULL, NULL);
1390         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_min_get", NULL, NULL);
1391         RNA_def_property_ui_text(prop, "Hard Minimum", "Minimum value used by buttons");
1392
1393         prop = RNA_def_property(srna, "hard_max", type, PROP_NONE);
1394         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1395         if (type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_max_get", NULL, NULL);
1396         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_max_get", NULL, NULL);
1397         RNA_def_property_ui_text(prop, "Hard Maximum", "Maximum value used by buttons");
1398
1399         prop = RNA_def_property(srna, "soft_min", type, PROP_NONE);
1400         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1401         if (type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_min_get", NULL, NULL);
1402         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_min_get", NULL, NULL);
1403         RNA_def_property_ui_text(prop, "Soft Minimum", "Minimum value used by buttons");
1404
1405         prop = RNA_def_property(srna, "soft_max", type, PROP_NONE);
1406         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1407         if (type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_max_get", NULL, NULL);
1408         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_max_get", NULL, NULL);
1409         RNA_def_property_ui_text(prop, "Soft Maximum", "Maximum value used by buttons");
1410
1411         prop = RNA_def_property(srna, "step", type, PROP_UNSIGNED);
1412         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1413         if (type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_step_get", NULL, NULL);
1414         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_step_get", NULL, NULL);
1415         RNA_def_property_ui_text(prop, "Step", "Step size used by number buttons, for floats 1/100th of the step size");
1416
1417         if (type == PROP_FLOAT) {
1418                 prop = RNA_def_property(srna, "precision", PROP_INT, PROP_UNSIGNED);
1419                 RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1420                 RNA_def_property_int_funcs(prop, "rna_FloatProperty_precision_get", NULL, NULL);
1421                 RNA_def_property_ui_text(prop, "Precision", "Number of digits after the dot used by buttons");
1422         }
1423 }
1424
1425 static void rna_def_string_property(StructRNA *srna)
1426 {
1427         PropertyRNA *prop;
1428
1429         prop = RNA_def_property(srna, "default", PROP_STRING, PROP_NONE);
1430         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1431         RNA_def_property_string_funcs(prop, "rna_StringProperty_default_get", "rna_StringProperty_default_length", NULL);
1432         RNA_def_property_ui_text(prop, "Default", "string default value");
1433
1434         prop = RNA_def_property(srna, "length_max", PROP_INT, PROP_UNSIGNED);
1435         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1436         RNA_def_property_int_funcs(prop, "rna_StringProperty_max_length_get", NULL, NULL);
1437         RNA_def_property_ui_text(prop, "Maximum Length", "Maximum length of the string, 0 means unlimited");
1438 }
1439
1440 static void rna_def_enum_property(BlenderRNA *brna, StructRNA *srna)
1441 {
1442         PropertyRNA *prop;
1443
1444         /* the itemf func is used instead, keep blender happy */
1445         static EnumPropertyItem default_dummy_items[] = {
1446                 {PROP_NONE, "DUMMY", 0, "Dummy", ""},
1447                 {0, NULL, 0, NULL, NULL}
1448         };
1449
1450         prop = RNA_def_property(srna, "default", PROP_ENUM, PROP_NONE);
1451         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1452         RNA_def_property_enum_items(prop, default_dummy_items);
1453         RNA_def_property_enum_funcs(prop, "rna_EnumProperty_default_get", NULL, "rna_EnumProperty_default_itemf");
1454         RNA_def_property_ui_text(prop, "Default", "Default value for this enum");
1455
1456         /* same 'default' but uses 'PROP_ENUM_FLAG' */
1457         prop = RNA_def_property(srna, "default_flag", PROP_ENUM, PROP_NONE);
1458         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1459         RNA_def_property_flag(prop, PROP_ENUM_FLAG);
1460         RNA_def_property_enum_items(prop, default_dummy_items);
1461         RNA_def_property_enum_funcs(prop, "rna_EnumProperty_default_get", NULL, "rna_EnumProperty_default_itemf");
1462         RNA_def_property_ui_text(prop, "Default", "Default value for this enum");
1463
1464         prop = RNA_def_property(srna, "enum_items", PROP_COLLECTION, PROP_NONE);
1465         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1466         RNA_def_property_struct_type(prop, "EnumPropertyItem");
1467         RNA_def_property_collection_funcs(prop, "rna_EnumProperty_items_begin", "rna_iterator_array_next",
1468                                           "rna_iterator_array_end", "rna_iterator_array_get", NULL, NULL, NULL, NULL);
1469         RNA_def_property_ui_text(prop, "Items", "Possible values for the property");
1470
1471         prop = RNA_def_property(srna, "enum_items_static", PROP_COLLECTION, PROP_NONE);
1472         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1473         RNA_def_property_struct_type(prop, "EnumPropertyItem");
1474         RNA_def_property_collection_funcs(prop, "rna_EnumProperty_items_begin", "rna_iterator_array_next",
1475                                           "rna_iterator_array_end", "rna_iterator_array_get", NULL, NULL, NULL, NULL);
1476         RNA_def_property_ui_text(prop, "Static Items",
1477                                  "Possible values for the property (never calls optional dynamic generation of those)");
1478
1479         srna = RNA_def_struct(brna, "EnumPropertyItem", NULL);
1480         RNA_def_struct_ui_text(srna, "Enum Item Definition", "Definition of a choice in an RNA enum property");
1481         RNA_def_struct_ui_icon(srna, ICON_RNA);
1482
1483         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1484         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1485         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_name_get", "rna_EnumPropertyItem_name_length", NULL);
1486         RNA_def_property_ui_text(prop, "Name", "Human readable name");
1487
1488         prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
1489         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1490         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_description_get",
1491                                       "rna_EnumPropertyItem_description_length", NULL);
1492         RNA_def_property_ui_text(prop, "Description", "Description of the item's purpose");
1493
1494         prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
1495         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1496         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_identifier_get",
1497                                       "rna_EnumPropertyItem_identifier_length", NULL);
1498         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
1499         RNA_def_struct_name_property(srna, prop);
1500
1501         prop = RNA_def_property(srna, "value", PROP_INT, PROP_UNSIGNED);
1502         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1503         RNA_def_property_int_funcs(prop, "rna_EnumPropertyItem_value_get", NULL, NULL);
1504         RNA_def_property_ui_text(prop, "Value", "Value of the item");
1505
1506         prop = RNA_def_property(srna, "icon", PROP_ENUM, PROP_NONE);
1507         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1508         RNA_def_property_enum_items(prop, rna_enum_icon_items);
1509         RNA_def_property_enum_funcs(prop, "rna_EnumPropertyItem_icon_get", NULL, NULL);
1510         RNA_def_property_ui_text(prop, "Icon", "Icon of the item");
1511 }
1512
1513 static void rna_def_pointer_property(StructRNA *srna, PropertyType type)
1514 {
1515         PropertyRNA *prop;
1516
1517         prop = RNA_def_property(srna, "fixed_type", PROP_POINTER, PROP_NONE);
1518         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1519         RNA_def_property_struct_type(prop, "Struct");
1520         if (type == PROP_POINTER)
1521                 RNA_def_property_pointer_funcs(prop, "rna_PointerProperty_fixed_type_get", NULL, NULL, NULL);
1522         else
1523                 RNA_def_property_pointer_funcs(prop, "rna_CollectionProperty_fixed_type_get", NULL, NULL, NULL);
1524         RNA_def_property_ui_text(prop, "Pointer Type", "Fixed pointer type, empty if variable type");
1525 }
1526
1527 void RNA_def_rna(BlenderRNA *brna)
1528 {
1529         StructRNA *srna;
1530         PropertyRNA *prop;
1531
1532         /* Struct*/
1533         rna_def_struct(brna);
1534
1535         /* Property */
1536         rna_def_property(brna);
1537
1538         /* BoolProperty */
1539         srna = RNA_def_struct(brna, "BoolProperty", "Property");
1540         RNA_def_struct_ui_text(srna, "Boolean Definition", "RNA boolean property definition");
1541         rna_def_number_property(srna, PROP_BOOLEAN);
1542
1543         /* IntProperty */
1544         srna = RNA_def_struct(brna, "IntProperty", "Property");
1545         RNA_def_struct_ui_text(srna, "Int Definition", "RNA integer number property definition");
1546         rna_def_number_property(srna, PROP_INT);
1547
1548         /* FloatProperty */
1549         srna = RNA_def_struct(brna, "FloatProperty", "Property");
1550         RNA_def_struct_ui_text(srna, "Float Definition", "RNA floating pointer number property definition");
1551         rna_def_number_property(srna, PROP_FLOAT);
1552
1553         /* StringProperty */
1554         srna = RNA_def_struct(brna, "StringProperty", "Property");
1555         RNA_def_struct_ui_text(srna, "String Definition", "RNA text string property definition");
1556         rna_def_string_property(srna);
1557
1558         /* EnumProperty */
1559         srna = RNA_def_struct(brna, "EnumProperty", "Property");
1560         RNA_def_struct_ui_text(srna, "Enum Definition",
1561                                "RNA enumeration property definition, to choose from a number of predefined options");
1562         rna_def_enum_property(brna, srna);
1563
1564         /* PointerProperty */
1565         srna = RNA_def_struct(brna, "PointerProperty", "Property");
1566         RNA_def_struct_ui_text(srna, "Pointer Definition", "RNA pointer property to point to another RNA struct");
1567         rna_def_pointer_property(srna, PROP_POINTER);
1568
1569         /* CollectionProperty */
1570         srna = RNA_def_struct(brna, "CollectionProperty", "Property");
1571         RNA_def_struct_ui_text(srna, "Collection Definition",
1572                                "RNA collection property to define lists, arrays and mappings");
1573         rna_def_pointer_property(srna, PROP_COLLECTION);
1574         
1575         /* Function */
1576         rna_def_function(brna);
1577
1578         /* Blender RNA */
1579         srna = RNA_def_struct(brna, "BlenderRNA", NULL);
1580         RNA_def_struct_ui_text(srna, "Blender RNA", "Blender RNA structure definitions");
1581         RNA_def_struct_ui_icon(srna, ICON_RNA);
1582
1583         prop = RNA_def_property(srna, "structs", PROP_COLLECTION, PROP_NONE);
1584         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1585         RNA_def_property_struct_type(prop, "Struct");
1586         RNA_def_property_collection_funcs(prop, "rna_BlenderRNA_structs_begin", "rna_iterator_listbase_next",
1587                                           "rna_iterator_listbase_end", "rna_iterator_listbase_get",
1588                                           /* included for speed, can be removed */
1589 #if 0
1590                                           NULL, NULL, NULL, NULL);
1591 #else
1592                                           "rna_BlenderRNA_structs_length", "rna_BlenderRNA_structs_lookup_int",
1593                                           "rna_BlenderRNA_structs_lookup_string", NULL);
1594 #endif
1595
1596         RNA_def_property_ui_text(prop, "Structs", "");
1597 }
1598
1599 #endif