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