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