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