fix for py/rna mesh.materials[:] where empty materials exist, would raise a runtime...
[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 int rna_builtin_properties_lookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
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
319                                 *r_ptr= propptr;
320                                 return TRUE;
321                         }
322                 }
323
324                 for(prop=srna->cont.properties.first; prop; prop=prop->next) {
325                         if(!(prop->flag & PROP_BUILTIN) && strcmp(prop->identifier, key)==0) {
326                                 propptr.type= &RNA_Property;
327                                 propptr.data= prop;
328
329                                 *r_ptr= propptr;
330                                 return TRUE;
331                         }
332                 }
333         } while((srna=srna->base));
334
335         /* this was used pre 2.5beta0, now ID property access uses python's
336          * getitem style access
337          * - ob["foo"] rather then ob.foo */
338 #if 0
339         if(ptr->data) {
340                 IDProperty *group, *idp;
341
342                 group= RNA_struct_idprops(ptr, 0);
343
344                 if(group) {
345                         for(idp=group->data.group.first; idp; idp=idp->next) {
346                                 if(strcmp(idp->name, key) == 0) {
347                                         propptr.type= &RNA_Property;
348                                         propptr.data= idp;
349
350                                         *r_ptr= propptr;
351                                         return TRUE;
352                                 }
353                         }
354                 }
355         }
356 #endif
357         return FALSE;
358 }
359
360 PointerRNA rna_builtin_type_get(PointerRNA *ptr)
361 {
362         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ptr->type);
363 }
364
365 /* Property */
366
367 static StructRNA *rna_Property_refine(PointerRNA *ptr)
368 {
369         PropertyRNA *prop= (PropertyRNA*)ptr->data;
370
371         rna_idproperty_check(&prop, ptr); /* XXX ptr? */
372
373         switch(prop->type) {
374                 case PROP_BOOLEAN: return &RNA_BooleanProperty;
375                 case PROP_INT: return &RNA_IntProperty;
376                 case PROP_FLOAT: return &RNA_FloatProperty;
377                 case PROP_STRING: return &RNA_StringProperty;
378                 case PROP_ENUM: return &RNA_EnumProperty;
379                 case PROP_POINTER: return &RNA_PointerProperty;
380                 case PROP_COLLECTION: return &RNA_CollectionProperty;
381                 default: return &RNA_Property;
382         }
383 }
384
385 static void rna_Property_identifier_get(PointerRNA *ptr, char *value)
386 {
387         PropertyRNA *prop= (PropertyRNA*)ptr->data;
388         rna_idproperty_check(&prop, ptr);
389         strcpy(value, ((PropertyRNA*)prop)->identifier);
390 }
391
392 static int rna_Property_identifier_length(PointerRNA *ptr)
393 {
394         PropertyRNA *prop= (PropertyRNA*)ptr->data;
395         rna_idproperty_check(&prop, ptr);
396         return strlen(prop->identifier);
397 }
398
399 static void rna_Property_name_get(PointerRNA *ptr, char *value)
400 {
401         PropertyRNA *prop= (PropertyRNA*)ptr->data;
402         rna_idproperty_check(&prop, ptr);
403         strcpy(value, prop->name);
404 }
405
406 static int rna_Property_name_length(PointerRNA *ptr)
407 {
408         PropertyRNA *prop= (PropertyRNA*)ptr->data;
409         rna_idproperty_check(&prop, ptr);
410         return strlen(prop->name);
411 }
412
413 static void rna_Property_description_get(PointerRNA *ptr, char *value)
414 {
415         PropertyRNA *prop= (PropertyRNA*)ptr->data;
416         rna_idproperty_check(&prop, ptr);
417         strcpy(value, prop->description ? prop->description:"");
418 }
419 static int rna_Property_description_length(PointerRNA *ptr)
420 {
421         PropertyRNA *prop= (PropertyRNA*)ptr->data;
422         rna_idproperty_check(&prop, ptr);
423         return prop->description ? strlen(prop->description) : 0;
424 }
425
426 static int rna_Property_type_get(PointerRNA *ptr)
427 {
428         PropertyRNA *prop= (PropertyRNA*)ptr->data;
429         rna_idproperty_check(&prop, ptr);
430         return prop->type;
431 }
432
433 static int rna_Property_subtype_get(PointerRNA *ptr)
434 {
435         PropertyRNA *prop= (PropertyRNA*)ptr->data;
436         rna_idproperty_check(&prop, ptr);
437         return prop->subtype;
438 }
439
440 static PointerRNA rna_Property_srna_get(PointerRNA *ptr)
441 {
442         PropertyRNA *prop= (PropertyRNA*)ptr->data;
443         rna_idproperty_check(&prop, ptr);
444         return rna_pointer_inherit_refine(ptr, &RNA_Struct, prop->srna);
445 }
446
447 static int rna_Property_unit_get(PointerRNA *ptr)
448 {
449         PropertyRNA *prop= (PropertyRNA*)ptr->data;
450         rna_idproperty_check(&prop, ptr);
451         return RNA_SUBTYPE_UNIT(prop->subtype);
452 }
453
454 static int rna_Property_readonly_get(PointerRNA *ptr)
455 {
456         PropertyRNA *prop= (PropertyRNA*)ptr->data;
457
458         /* dont use this becaure it will call functions that check the internal
459          * data for introspection we only need to know if it can be edited so the
460          * flag is better for this */
461 //      return RNA_property_editable(ptr, prop);
462         return prop->flag & PROP_EDITABLE ? 0:1;
463 }
464
465 static int rna_Property_use_output_get(PointerRNA *ptr)
466 {
467         PropertyRNA *prop= (PropertyRNA*)ptr->data;
468         return prop->flag & PROP_OUTPUT ? 1:0;
469 }
470
471 static int rna_Property_is_required_get(PointerRNA *ptr)
472 {
473         PropertyRNA *prop= (PropertyRNA*)ptr->data;
474         return prop->flag & PROP_REQUIRED ? 1:0;
475 }
476
477 static int rna_Property_is_never_none_get(PointerRNA *ptr)
478 {
479         PropertyRNA *prop= (PropertyRNA*)ptr->data;
480         return prop->flag & PROP_NEVER_NULL ? 1:0;
481 }
482
483 static int rna_Property_is_hidden_get(PointerRNA *ptr)
484 {
485         PropertyRNA *prop= (PropertyRNA*)ptr->data;
486         return prop->flag & PROP_HIDDEN ? 1:0;
487 }
488
489 static int rna_Property_array_length_get(PointerRNA *ptr)
490 {
491         PropertyRNA *prop= (PropertyRNA*)ptr->data;
492         rna_idproperty_check(&prop, ptr);
493         return prop->totarraylength;
494 }
495
496 static int rna_Property_registered_get(PointerRNA *ptr)
497 {
498         PropertyRNA *prop= (PropertyRNA*)ptr->data;
499         return prop->flag & PROP_REGISTER;
500 }
501
502 static int rna_Property_registered_optional_get(PointerRNA *ptr)
503 {
504         PropertyRNA *prop= (PropertyRNA*)ptr->data;
505         return prop->flag & PROP_REGISTER_OPTIONAL;
506 }
507
508 static int rna_Property_runtime_get(PointerRNA *ptr)
509 {
510         PropertyRNA *prop= (PropertyRNA*)ptr->data;
511         return prop->flag & PROP_RUNTIME;
512 }
513
514
515 static int rna_BoolProperty_default_get(PointerRNA *ptr)
516 {
517         PropertyRNA *prop= (PropertyRNA*)ptr->data;
518         rna_idproperty_check(&prop, ptr);
519         return ((BooleanPropertyRNA*)prop)->defaultvalue;
520 }
521
522 static int rna_IntProperty_default_get(PointerRNA *ptr)
523 {
524         PropertyRNA *prop= (PropertyRNA*)ptr->data;
525         rna_idproperty_check(&prop, ptr);
526         return ((IntPropertyRNA*)prop)->defaultvalue;
527 }
528 /* int/float/bool */
529 static int rna_NumberProperty_default_array_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
530 {
531         PropertyRNA *prop= (PropertyRNA*)ptr->data;
532         rna_idproperty_check(&prop, ptr);
533
534         length[0]= prop->totarraylength;
535
536         return length[0];
537 }
538 static void rna_IntProperty_default_array_get(PointerRNA *ptr, int *values)
539 {
540         PropertyRNA *prop= (PropertyRNA*)ptr->data;
541         IntPropertyRNA *nprop= (IntPropertyRNA*)prop;
542         rna_idproperty_check(&prop, ptr);
543
544         if(nprop->defaultarray) {
545                 memcpy(values, nprop->defaultarray, prop->totarraylength * sizeof(int));
546         }
547         else {
548                 int i;
549                 for(i=0; i < prop->totarraylength; i++)
550                         values[i]= nprop->defaultvalue;
551         }
552 }
553 static void rna_BoolProperty_default_array_get(PointerRNA *ptr, int *values)
554 {
555         PropertyRNA *prop= (PropertyRNA*)ptr->data;
556         BooleanPropertyRNA *nprop= (BooleanPropertyRNA*)prop;
557         rna_idproperty_check(&prop, ptr);
558
559         if(nprop->defaultarray) {
560                 memcpy(values, nprop->defaultarray, prop->totarraylength * sizeof(int));
561         }
562         else {
563                 int i;
564                 for(i=0; i < prop->totarraylength; i++)
565                         values[i]= nprop->defaultvalue;
566         }
567 }
568 static void rna_FloatProperty_default_array_get(PointerRNA *ptr, float *values)
569 {
570         PropertyRNA *prop= (PropertyRNA*)ptr->data;
571         FloatPropertyRNA *nprop= (FloatPropertyRNA*)prop;
572         rna_idproperty_check(&prop, ptr);
573
574         if(nprop->defaultarray) {
575                 memcpy(values, nprop->defaultarray, prop->totarraylength * sizeof(float));
576         }
577         else {
578                 int i;
579                 for(i=0; i < prop->totarraylength; i++)
580                         values[i]= nprop->defaultvalue;
581         }
582 }
583
584 static int rna_IntProperty_hard_min_get(PointerRNA *ptr)
585 {
586         PropertyRNA *prop= (PropertyRNA*)ptr->data;
587         rna_idproperty_check(&prop, ptr);
588         return ((IntPropertyRNA*)prop)->hardmin;
589 }
590
591 static int rna_IntProperty_hard_max_get(PointerRNA *ptr)
592 {
593         PropertyRNA *prop= (PropertyRNA*)ptr->data;
594         rna_idproperty_check(&prop, ptr);
595         return ((IntPropertyRNA*)prop)->hardmax;
596 }
597
598 static int rna_IntProperty_soft_min_get(PointerRNA *ptr)
599 {
600         PropertyRNA *prop= (PropertyRNA*)ptr->data;
601         rna_idproperty_check(&prop, ptr);
602         return ((IntPropertyRNA*)prop)->softmin;
603 }
604
605 static int rna_IntProperty_soft_max_get(PointerRNA *ptr)
606 {
607         PropertyRNA *prop= (PropertyRNA*)ptr->data;
608         rna_idproperty_check(&prop, ptr);
609         return ((IntPropertyRNA*)prop)->softmax;
610 }
611
612 static int rna_IntProperty_step_get(PointerRNA *ptr)
613 {
614         PropertyRNA *prop= (PropertyRNA*)ptr->data;
615         rna_idproperty_check(&prop, ptr);
616         return ((IntPropertyRNA*)prop)->step;
617 }
618
619 static float rna_FloatProperty_default_get(PointerRNA *ptr)
620 {
621         PropertyRNA *prop= (PropertyRNA*)ptr->data;
622         rna_idproperty_check(&prop, ptr);
623         return ((FloatPropertyRNA*)prop)->defaultvalue;
624 }
625 static float rna_FloatProperty_hard_min_get(PointerRNA *ptr)
626 {
627         PropertyRNA *prop= (PropertyRNA*)ptr->data;
628         rna_idproperty_check(&prop, ptr);
629         return ((FloatPropertyRNA*)prop)->hardmin;
630 }
631
632 static float rna_FloatProperty_hard_max_get(PointerRNA *ptr)
633 {
634         PropertyRNA *prop= (PropertyRNA*)ptr->data;
635         rna_idproperty_check(&prop, ptr);
636         return ((FloatPropertyRNA*)prop)->hardmax;
637 }
638
639 static float rna_FloatProperty_soft_min_get(PointerRNA *ptr)
640 {
641         PropertyRNA *prop= (PropertyRNA*)ptr->data;
642         rna_idproperty_check(&prop, ptr);
643         return ((FloatPropertyRNA*)prop)->softmin;
644 }
645
646 static float rna_FloatProperty_soft_max_get(PointerRNA *ptr)
647 {
648         PropertyRNA *prop= (PropertyRNA*)ptr->data;
649         rna_idproperty_check(&prop, ptr);
650         return ((FloatPropertyRNA*)prop)->softmax;
651 }
652
653 static float rna_FloatProperty_step_get(PointerRNA *ptr)
654 {
655         PropertyRNA *prop= (PropertyRNA*)ptr->data;
656         rna_idproperty_check(&prop, ptr);
657         return ((FloatPropertyRNA*)prop)->step;
658 }
659
660 static int rna_FloatProperty_precision_get(PointerRNA *ptr)
661 {
662         PropertyRNA *prop= (PropertyRNA*)ptr->data;
663         rna_idproperty_check(&prop, ptr);
664         return ((FloatPropertyRNA*)prop)->precision;
665 }
666
667 static void rna_StringProperty_default_get(PointerRNA *ptr, char *value)
668 {
669         PropertyRNA *prop= (PropertyRNA*)ptr->data;
670         rna_idproperty_check(&prop, ptr);
671         strcpy(value, ((StringPropertyRNA*)prop)->defaultvalue);
672 }
673 static int rna_StringProperty_default_length(PointerRNA *ptr)
674 {
675         PropertyRNA *prop= (PropertyRNA*)ptr->data;
676         rna_idproperty_check(&prop, ptr);
677         return strlen(((StringPropertyRNA*)prop)->defaultvalue);
678 }
679
680 static int rna_StringProperty_max_length_get(PointerRNA *ptr)
681 {
682         PropertyRNA *prop= (PropertyRNA*)ptr->data;
683         rna_idproperty_check(&prop, ptr);
684         return ((StringPropertyRNA*)prop)->maxlength;
685 }
686
687 static EnumPropertyItem *rna_EnumProperty_default_itemf(bContext *C, PointerRNA *ptr, int *free)
688 {
689         PropertyRNA *prop= (PropertyRNA*)ptr->data;
690         EnumPropertyRNA *eprop;
691
692         rna_idproperty_check(&prop, ptr);
693         eprop= (EnumPropertyRNA*)prop;
694
695         if(             (eprop->itemf == NULL) ||
696                         (eprop->itemf == rna_EnumProperty_default_itemf) ||
697                         (ptr->type == &RNA_EnumProperty) ||
698                         (C == NULL))
699         {
700                 return eprop->item;
701         }
702
703         return eprop->itemf(C, ptr, free);
704 }
705
706 /* XXX - not sure this is needed? */
707 static int rna_EnumProperty_default_get(PointerRNA *ptr)
708 {
709         PropertyRNA *prop= (PropertyRNA*)ptr->data;
710         rna_idproperty_check(&prop, ptr);
711         return ((EnumPropertyRNA*)prop)->defaultvalue;
712 }
713
714 static int rna_enum_check_separator(CollectionPropertyIterator *iter, void *data)
715 {
716         EnumPropertyItem *item= (EnumPropertyItem*)data;
717
718         return (item->identifier[0] == 0);
719 }
720
721 static void rna_EnumProperty_items_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
722 {
723         PropertyRNA *prop= (PropertyRNA*)ptr->data;
724         EnumPropertyRNA *eprop;
725         EnumPropertyItem *item= NULL;
726         int totitem, free= 0;
727         
728         rna_idproperty_check(&prop, ptr);
729         eprop= (EnumPropertyRNA*)prop;
730         
731         RNA_property_enum_items(NULL, ptr, prop, &item, &totitem, &free);
732         rna_iterator_array_begin(iter, (void*)item, sizeof(EnumPropertyItem), totitem, free, rna_enum_check_separator);
733 }
734
735 static void rna_EnumPropertyItem_identifier_get(PointerRNA *ptr, char *value)
736 {
737         strcpy(value, ((EnumPropertyItem*)ptr->data)->identifier);
738 }
739
740 static int rna_EnumPropertyItem_identifier_length(PointerRNA *ptr)
741 {
742         return strlen(((EnumPropertyItem*)ptr->data)->identifier);
743 }
744
745 static void rna_EnumPropertyItem_name_get(PointerRNA *ptr, char *value)
746 {
747         strcpy(value, ((EnumPropertyItem*)ptr->data)->name);
748 }
749
750 static int rna_EnumPropertyItem_name_length(PointerRNA *ptr)
751 {
752         return strlen(((EnumPropertyItem*)ptr->data)->name);
753 }
754
755 static void rna_EnumPropertyItem_description_get(PointerRNA *ptr, char *value)
756 {
757         EnumPropertyItem *eprop= (EnumPropertyItem*)ptr->data;
758
759         if(eprop->description)
760                 strcpy(value, eprop->description);
761         else
762                 value[0]= '\0';
763 }
764
765 static int rna_EnumPropertyItem_description_length(PointerRNA *ptr)
766 {
767         EnumPropertyItem *eprop= (EnumPropertyItem*)ptr->data;
768
769         if(eprop->description)
770                 return strlen(eprop->description);
771         else
772                 return 0;
773 }
774
775 static int rna_EnumPropertyItem_value_get(PointerRNA *ptr)
776 {
777         return ((EnumPropertyItem*)ptr->data)->value;
778 }
779
780 static PointerRNA rna_PointerProperty_fixed_type_get(PointerRNA *ptr)
781 {
782         PropertyRNA *prop= (PropertyRNA*)ptr->data;
783         rna_idproperty_check(&prop, ptr);
784         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((PointerPropertyRNA*)prop)->type);
785 }
786
787 static PointerRNA rna_CollectionProperty_fixed_type_get(PointerRNA *ptr)
788 {
789         PropertyRNA *prop= (PropertyRNA*)ptr->data;
790         rna_idproperty_check(&prop, ptr);
791         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((CollectionPropertyRNA*)prop)->item_type);
792 }
793
794 /* Function */
795
796 static void rna_Function_identifier_get(PointerRNA *ptr, char *value)
797 {
798         strcpy(value, ((FunctionRNA*)ptr->data)->identifier);
799 }
800
801 static int rna_Function_identifier_length(PointerRNA *ptr)
802 {
803         return strlen(((FunctionRNA*)ptr->data)->identifier);
804 }
805
806 static void rna_Function_description_get(PointerRNA *ptr, char *value)
807 {
808         strcpy(value, ((FunctionRNA*)ptr->data)->description);
809 }
810
811 static int rna_Function_description_length(PointerRNA *ptr)
812 {
813         return strlen(((FunctionRNA*)ptr->data)->description);
814 }
815
816 static void rna_Function_parameters_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
817 {
818         rna_iterator_listbase_begin(iter, &((FunctionRNA*)ptr->data)->cont.properties, rna_property_builtin);
819 }
820
821 static int rna_Function_registered_get(PointerRNA *ptr)
822 {
823         FunctionRNA *func= (FunctionRNA*)ptr->data;
824         return func->flag & FUNC_REGISTER;
825 }
826
827 static int rna_Function_registered_optional_get(PointerRNA *ptr)
828 {
829         FunctionRNA *func= (FunctionRNA*)ptr->data;
830         return func->flag & FUNC_REGISTER_OPTIONAL;
831 }
832
833 static int rna_Function_no_self_get(PointerRNA *ptr)
834 {
835         FunctionRNA *func= (FunctionRNA*)ptr->data;
836         return !(func->flag & FUNC_NO_SELF);
837 }
838
839 /* Blender RNA */
840
841 static void rna_BlenderRNA_structs_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
842 {
843         rna_iterator_listbase_begin(iter, &((BlenderRNA*)ptr->data)->structs, NULL);
844 }
845
846 /* optional, for faster lookups */
847 static int rna_BlenderRNA_structs_length(PointerRNA *ptr)
848 {
849         return BLI_countlist(&((BlenderRNA*)ptr->data)->structs);
850 }
851 static int rna_BlenderRNA_structs_lookup_int(PointerRNA *ptr, int index, PointerRNA *r_ptr)
852 {
853         StructRNA *srna= BLI_findlink(&((BlenderRNA*)ptr->data)->structs, index);
854
855         if(srna) {
856                 RNA_pointer_create(NULL, &RNA_Struct, srna, r_ptr);
857                 return TRUE;
858         }
859         else {
860                 return FALSE;
861         }
862 }
863 static int rna_BlenderRNA_structs_lookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
864 {
865         StructRNA *srna= ((BlenderRNA*)ptr->data)->structs.first;
866         for(; srna; srna=srna->cont.next) {
867                 if(key[0] == srna->identifier[0] && strcmp(key, srna->identifier)==0) {
868                         RNA_pointer_create(NULL, &RNA_Struct, srna, r_ptr);
869                         return TRUE;
870                 }
871         }
872
873         return FALSE;
874 }
875
876
877 #else
878
879 static void rna_def_struct(BlenderRNA *brna)
880 {
881         StructRNA *srna;
882         PropertyRNA *prop;
883
884         srna= RNA_def_struct(brna, "Struct", NULL);
885         RNA_def_struct_ui_text(srna, "Struct Definition", "RNA structure definition");
886         RNA_def_struct_ui_icon(srna, ICON_RNA);
887
888         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
889         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
890         RNA_def_property_string_funcs(prop, "rna_Struct_name_get", "rna_Struct_name_length", NULL);
891         RNA_def_property_ui_text(prop, "Name", "Human readable name");
892
893         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
894         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
895         RNA_def_property_string_funcs(prop, "rna_Struct_identifier_get", "rna_Struct_identifier_length", NULL);
896         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
897         RNA_def_struct_name_property(srna, prop);
898         
899         prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
900         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
901         RNA_def_property_string_funcs(prop, "rna_Struct_description_get", "rna_Struct_description_length", NULL);
902         RNA_def_property_ui_text(prop, "Description", "Description of the Struct's purpose");
903         
904         prop= RNA_def_property(srna, "base", PROP_POINTER, PROP_NONE);
905         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
906         RNA_def_property_struct_type(prop, "Struct");
907         RNA_def_property_pointer_funcs(prop, "rna_Struct_base_get", NULL, NULL, NULL);
908         RNA_def_property_ui_text(prop, "Base", "Struct definition this is derived from");
909
910         prop= RNA_def_property(srna, "nested", PROP_POINTER, PROP_NONE);
911         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
912         RNA_def_property_struct_type(prop, "Struct");
913         RNA_def_property_pointer_funcs(prop, "rna_Struct_nested_get", NULL, NULL, NULL);
914         RNA_def_property_ui_text(prop, "Nested", "Struct in which this struct is always nested, and to which it logically belongs");
915
916         prop= RNA_def_property(srna, "name_property", PROP_POINTER, PROP_NONE);
917         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
918         RNA_def_property_struct_type(prop, "StringProperty");
919         RNA_def_property_pointer_funcs(prop, "rna_Struct_name_property_get", NULL, NULL, NULL);
920         RNA_def_property_ui_text(prop, "Name Property", "Property that gives the name of the struct");
921
922         prop= RNA_def_property(srna, "properties", PROP_COLLECTION, PROP_NONE);
923         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
924         RNA_def_property_struct_type(prop, "Property");
925         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);
926         RNA_def_property_ui_text(prop, "Properties", "Properties in the struct");
927
928         prop= RNA_def_property(srna, "functions", PROP_COLLECTION, PROP_NONE);
929         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
930         RNA_def_property_struct_type(prop, "Function");
931         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);
932         RNA_def_property_ui_text(prop, "Functions", "");
933 }
934
935 static void rna_def_property(BlenderRNA *brna)
936 {
937         StructRNA *srna;
938         PropertyRNA *prop;
939         static EnumPropertyItem subtype_items[] = {
940                 {PROP_NONE, "NONE", 0, "None", ""},
941                 {PROP_FILEPATH, "FILE_PATH", 0, "File Path", ""},
942                 {PROP_DIRPATH, "DIRECTORY_PATH", 0, "Directory Path", ""},
943                 {PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned Number", ""},
944                 {PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", ""},
945                 {PROP_FACTOR, "FACTOR", 0, "Factor", ""},
946                 {PROP_ANGLE, "ANGLE", 0, "Angle", ""},
947                 {PROP_TIME, "TIME", 0, "Time", ""},
948                 {PROP_DISTANCE, "DISTANCE", 0, "Distance", ""},
949                 {PROP_COLOR, "COLOR", 0, "Color", ""},
950                 {PROP_TRANSLATION, "TRANSLATION", 0, "Translation", ""},
951                 {PROP_DIRECTION, "DIRECTION", 0, "Direction", ""},
952                 {PROP_MATRIX, "MATRIX", 0, "Matrix", ""},
953                 {PROP_EULER, "EULER", 0, "Euler", ""},
954                 {PROP_QUATERNION, "QUATERNION", 0, "Quaternion", ""},
955                 {PROP_XYZ, "XYZ", 0, "XYZ", ""},
956                 {PROP_COLOR_GAMMA, "COLOR_GAMMA", 0, "Gamma Corrected Color", ""},
957                 {PROP_LAYER, "LAYER", 0, "Layer", ""},
958                 {PROP_LAYER_MEMBER, "LAYER_MEMBERSHIP", 0, "Layer Membership", ""},
959                 {0, NULL, 0, NULL, NULL}};
960
961         srna= RNA_def_struct(brna, "Property", NULL);
962         RNA_def_struct_ui_text(srna, "Property Definition", "RNA property definition");
963         RNA_def_struct_refine_func(srna, "rna_Property_refine");
964         RNA_def_struct_ui_icon(srna, ICON_RNA);
965
966         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
967         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
968         RNA_def_property_string_funcs(prop, "rna_Property_name_get", "rna_Property_name_length", NULL);
969         RNA_def_property_ui_text(prop, "Name", "Human readable name");
970
971         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
972         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
973         RNA_def_property_string_funcs(prop, "rna_Property_identifier_get", "rna_Property_identifier_length", NULL);
974         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
975         RNA_def_struct_name_property(srna, prop);
976                 
977         prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
978         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
979         RNA_def_property_string_funcs(prop, "rna_Property_description_get", "rna_Property_description_length", NULL);
980         RNA_def_property_ui_text(prop, "Description", "Description of the property for tooltips");
981
982         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
983         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
984         RNA_def_property_enum_items(prop, property_type_items);
985         RNA_def_property_enum_funcs(prop, "rna_Property_type_get", NULL, NULL);
986         RNA_def_property_ui_text(prop, "Type", "Data type of the property");
987
988         prop= RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
989         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
990         RNA_def_property_enum_items(prop, subtype_items);
991         RNA_def_property_enum_funcs(prop, "rna_Property_subtype_get", NULL, NULL);
992         RNA_def_property_ui_text(prop, "Subtype", "Semantic interpretation of the property");
993
994         prop= RNA_def_property(srna, "srna", PROP_POINTER, PROP_NONE);
995         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
996         RNA_def_property_struct_type(prop, "Struct");
997         RNA_def_property_pointer_funcs(prop, "rna_Property_srna_get", NULL, NULL, NULL);
998         RNA_def_property_ui_text(prop, "Base", "Struct definition used for properties assigned to this item");
999
1000         prop= RNA_def_property(srna, "unit", PROP_ENUM, PROP_NONE);
1001         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1002         RNA_def_property_enum_items(prop, property_unit_items);
1003         RNA_def_property_enum_funcs(prop, "rna_Property_unit_get", NULL, NULL);
1004         RNA_def_property_ui_text(prop, "Unit", "Type of units for this property");
1005
1006         prop= RNA_def_property(srna, "is_readonly", PROP_BOOLEAN, PROP_NONE);
1007         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1008         RNA_def_property_boolean_funcs(prop, "rna_Property_readonly_get", NULL);
1009         RNA_def_property_ui_text(prop, "Read Only", "Property is editable through RNA");
1010
1011         prop= RNA_def_property(srna, "is_required", PROP_BOOLEAN, PROP_NONE);
1012         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1013         RNA_def_property_boolean_funcs(prop, "rna_Property_is_required_get", NULL);
1014         RNA_def_property_ui_text(prop, "Required", "False when this property is an optional argument in an RNA function");
1015
1016         prop= RNA_def_property(srna, "is_never_none", PROP_BOOLEAN, PROP_NONE);
1017         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1018         RNA_def_property_boolean_funcs(prop, "rna_Property_is_never_none_get", NULL);
1019         RNA_def_property_ui_text(prop, "Never None", "True when this value can't be set to None");
1020
1021         prop= RNA_def_property(srna, "is_hidden", PROP_BOOLEAN, PROP_NONE);
1022         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1023         RNA_def_property_boolean_funcs(prop, "rna_Property_is_hidden_get", NULL);
1024         RNA_def_property_ui_text(prop, "Hidden", "True when the property is hidden");
1025
1026         prop= RNA_def_property(srna, "is_output", PROP_BOOLEAN, PROP_NONE);
1027         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1028         RNA_def_property_boolean_funcs(prop, "rna_Property_use_output_get", NULL);
1029         RNA_def_property_ui_text(prop, "Return", "True when this property is an output value from an RNA function");
1030
1031         prop= RNA_def_property(srna, "is_registered", PROP_BOOLEAN, PROP_NONE);
1032         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1033         RNA_def_property_boolean_funcs(prop, "rna_Property_registered_get", NULL);
1034         RNA_def_property_ui_text(prop, "Registered", "Property is registered as part of type registration");
1035
1036         prop= RNA_def_property(srna, "is_registered_optional", PROP_BOOLEAN, PROP_NONE);
1037         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1038         RNA_def_property_boolean_funcs(prop, "rna_Property_registered_optional_get", NULL);
1039         RNA_def_property_ui_text(prop, "Registered Optionally", "Property is optionally registered as part of type registration");
1040         
1041         prop= RNA_def_property(srna, "is_runtime", PROP_BOOLEAN, PROP_NONE);
1042         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1043         RNA_def_property_boolean_funcs(prop, "rna_Property_runtime_get", NULL);
1044         RNA_def_property_ui_text(prop, "Read Only", "Property is editable through RNA");
1045 }
1046
1047 static void rna_def_function(BlenderRNA *brna)
1048 {
1049         StructRNA *srna;
1050         PropertyRNA *prop;
1051
1052         srna= RNA_def_struct(brna, "Function", NULL);
1053         RNA_def_struct_ui_text(srna, "Function Definition", "RNA function definition");
1054         RNA_def_struct_ui_icon(srna, ICON_RNA);
1055
1056         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
1057         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1058         RNA_def_property_string_funcs(prop, "rna_Function_identifier_get", "rna_Function_identifier_length", NULL);
1059         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
1060         RNA_def_struct_name_property(srna, prop);
1061
1062         prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
1063         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1064         RNA_def_property_string_funcs(prop, "rna_Function_description_get", "rna_Function_description_length", NULL);
1065         RNA_def_property_ui_text(prop, "Description", "Description of the Function's purpose");
1066
1067         prop= RNA_def_property(srna, "parameters", PROP_COLLECTION, PROP_NONE);
1068         /*RNA_def_property_clear_flag(prop, PROP_EDITABLE);*/
1069         RNA_def_property_struct_type(prop, "Property");
1070         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);
1071         RNA_def_property_ui_text(prop, "Parameters", "Parameters for the function");
1072
1073         prop= RNA_def_property(srna, "is_registered", PROP_BOOLEAN, PROP_NONE);
1074         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1075         RNA_def_property_boolean_funcs(prop, "rna_Function_registered_get", NULL);
1076         RNA_def_property_ui_text(prop, "Registered", "Function is registered as callback as part of type registration");
1077
1078         prop= RNA_def_property(srna, "is_registered_optional", PROP_BOOLEAN, PROP_NONE);
1079         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1080         RNA_def_property_boolean_funcs(prop, "rna_Function_registered_optional_get", NULL);
1081         RNA_def_property_ui_text(prop, "Registered Optionally", "Function is optionally registered as callback part of type registration");
1082
1083         prop= RNA_def_property(srna, "use_self", PROP_BOOLEAN, PROP_NONE);
1084         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1085         RNA_def_property_boolean_funcs(prop, "rna_Function_no_self_get", NULL);
1086         RNA_def_property_ui_text(prop, "No Self", "Function does not pass its self as an argument (becomes a class method in python)");
1087 }
1088
1089 static void rna_def_number_property(StructRNA *srna, PropertyType type)
1090 {
1091         PropertyRNA *prop;
1092
1093         prop= RNA_def_property(srna, "default", type, PROP_NONE);
1094         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1095         RNA_def_property_ui_text(prop, "Default", "Default value for this number");
1096
1097         switch(type) {
1098                 case PROP_BOOLEAN:
1099                         RNA_def_property_boolean_funcs(prop, "rna_BoolProperty_default_get", NULL);
1100                         break;
1101                 case PROP_INT:
1102                         RNA_def_property_int_funcs(prop, "rna_IntProperty_default_get", NULL, NULL);
1103                         break;
1104                 case PROP_FLOAT:
1105                         RNA_def_property_float_funcs(prop, "rna_FloatProperty_default_get", NULL, NULL);
1106                         break;
1107                 default:
1108                         break;
1109         }
1110
1111
1112         prop= RNA_def_property(srna, "default_array", type, PROP_NONE);
1113         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1114         RNA_def_property_array(prop, RNA_MAX_ARRAY_DIMENSION); /* no fixed default length, important its not 0 though */
1115         RNA_def_property_flag(prop, PROP_DYNAMIC);
1116         RNA_def_property_dynamic_array_funcs(prop, "rna_NumberProperty_default_array_get_length"); /* same for all types */
1117
1118         switch(type) {
1119                 case PROP_BOOLEAN:
1120                         RNA_def_property_boolean_funcs(prop, "rna_BoolProperty_default_array_get", NULL);
1121                         break;
1122                 case PROP_INT:
1123                         RNA_def_property_int_funcs(prop, "rna_IntProperty_default_array_get", NULL, NULL);
1124                         break;
1125                 case PROP_FLOAT:
1126                         RNA_def_property_float_funcs(prop, "rna_FloatProperty_default_array_get", NULL, NULL);
1127                         break;
1128                 default:
1129                         break;
1130         }
1131         RNA_def_property_ui_text(prop, "Default Array", "Default value for this array");
1132
1133
1134         prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_UNSIGNED);
1135         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1136         RNA_def_property_int_funcs(prop, "rna_Property_array_length_get", NULL, NULL);
1137         RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited");
1138
1139         if(type == PROP_BOOLEAN)
1140                 return;
1141
1142         prop= RNA_def_property(srna, "hard_min", type, PROP_NONE);
1143         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1144         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_min_get", NULL, NULL);
1145         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_min_get", NULL, NULL);
1146         RNA_def_property_ui_text(prop, "Hard Minimum", "Minimum value used by buttons");
1147
1148         prop= RNA_def_property(srna, "hard_max", type, PROP_NONE);
1149         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1150         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_max_get", NULL, NULL);
1151         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_max_get", NULL, NULL);
1152         RNA_def_property_ui_text(prop, "Hard Maximum", "Maximum value used by buttons");
1153
1154         prop= RNA_def_property(srna, "soft_min", type, PROP_NONE);
1155         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1156         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_min_get", NULL, NULL);
1157         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_min_get", NULL, NULL);
1158         RNA_def_property_ui_text(prop, "Soft Minimum", "Minimum value used by buttons");
1159
1160         prop= RNA_def_property(srna, "soft_max", type, PROP_NONE);
1161         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1162         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_max_get", NULL, NULL);
1163         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_max_get", NULL, NULL);
1164         RNA_def_property_ui_text(prop, "Soft Maximum", "Maximum value used by buttons");
1165
1166         prop= RNA_def_property(srna, "step", type, PROP_UNSIGNED);
1167         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1168         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_step_get", NULL, NULL);
1169         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_step_get", NULL, NULL);
1170         RNA_def_property_ui_text(prop, "Step", "Step size used by number buttons, for floats 1/100th of the step size");
1171
1172         if(type == PROP_FLOAT) {
1173                 prop= RNA_def_property(srna, "precision", PROP_INT, PROP_UNSIGNED);
1174                 RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1175                 RNA_def_property_int_funcs(prop, "rna_FloatProperty_precision_get", NULL, NULL);
1176                 RNA_def_property_ui_text(prop, "Precision", "Number of digits after the dot used by buttons");
1177         }
1178 }
1179
1180 static void rna_def_string_property(StructRNA *srna)
1181 {
1182         PropertyRNA *prop;
1183
1184         prop= RNA_def_property(srna, "default", PROP_STRING, PROP_NONE);
1185         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1186         RNA_def_property_string_funcs(prop, "rna_StringProperty_default_get", "rna_StringProperty_default_length", NULL);
1187         RNA_def_property_ui_text(prop, "Default", "string default value");
1188
1189         prop= RNA_def_property(srna, "length_max", PROP_INT, PROP_UNSIGNED);
1190         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1191         RNA_def_property_int_funcs(prop, "rna_StringProperty_max_length_get", NULL, NULL);
1192         RNA_def_property_ui_text(prop, "Maximum Length", "Maximum length of the string, 0 means unlimited");
1193 }
1194
1195 static void rna_def_enum_property(BlenderRNA *brna, StructRNA *srna)
1196 {
1197         PropertyRNA *prop;
1198
1199         /* the itemf func is used instead, keep blender happy */
1200         static EnumPropertyItem default_dummy_items[] = {
1201                 {PROP_NONE, "DUMMY", 0, "Dummy", ""},
1202                 {0, NULL, 0, NULL, NULL}};
1203
1204         prop= RNA_def_property(srna, "default", PROP_ENUM, PROP_NONE);
1205         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1206         RNA_def_property_enum_items(prop, default_dummy_items);
1207         RNA_def_property_enum_funcs(prop, "rna_EnumProperty_default_get", NULL, "rna_EnumProperty_default_itemf");
1208         RNA_def_property_ui_text(prop, "Default", "Default value for this enum");
1209
1210         prop= RNA_def_property(srna, "items", PROP_COLLECTION, PROP_NONE);
1211         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1212         RNA_def_property_struct_type(prop, "EnumPropertyItem");
1213         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);
1214         RNA_def_property_ui_text(prop, "Items", "Possible values for the property");
1215
1216         srna= RNA_def_struct(brna, "EnumPropertyItem", NULL);
1217         RNA_def_struct_ui_text(srna, "Enum Item Definition", "Definition of a choice in an RNA enum property");
1218         RNA_def_struct_ui_icon(srna, ICON_RNA);
1219
1220         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1221         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1222         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_name_get", "rna_EnumPropertyItem_name_length", NULL);
1223         RNA_def_property_ui_text(prop, "Name", "Human readable name");
1224
1225         prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
1226         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1227         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_description_get", "rna_EnumPropertyItem_description_length", NULL);
1228         RNA_def_property_ui_text(prop, "Description", "Description of the item's purpose");
1229
1230         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
1231         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1232         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_identifier_get", "rna_EnumPropertyItem_identifier_length", NULL);
1233         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
1234         RNA_def_struct_name_property(srna, prop);
1235
1236         prop= RNA_def_property(srna, "value", PROP_INT, PROP_UNSIGNED);
1237         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1238         RNA_def_property_int_funcs(prop, "rna_EnumPropertyItem_value_get", NULL, NULL);
1239         RNA_def_property_ui_text(prop, "Value", "Value of the item");
1240 }
1241
1242 static void rna_def_pointer_property(StructRNA *srna, PropertyType type)
1243 {
1244         PropertyRNA *prop;
1245
1246         prop= RNA_def_property(srna, "fixed_type", PROP_POINTER, PROP_NONE);
1247         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1248         RNA_def_property_struct_type(prop, "Struct");
1249         if(type == PROP_POINTER)
1250                 RNA_def_property_pointer_funcs(prop, "rna_PointerProperty_fixed_type_get", NULL, NULL, NULL);
1251         else
1252                 RNA_def_property_pointer_funcs(prop, "rna_CollectionProperty_fixed_type_get", NULL, NULL, NULL);
1253         RNA_def_property_ui_text(prop, "Pointer Type", "Fixed pointer type, empty if variable type");
1254 }
1255
1256 void RNA_def_rna(BlenderRNA *brna)
1257 {
1258         StructRNA *srna;
1259         PropertyRNA *prop;
1260
1261         /* Struct*/
1262         rna_def_struct(brna);
1263
1264         /* Property */
1265         rna_def_property(brna);
1266
1267         /* BooleanProperty */
1268         srna= RNA_def_struct(brna, "BooleanProperty", "Property");
1269         RNA_def_struct_ui_text(srna, "Boolean Definition", "RNA boolean property definition");
1270         rna_def_number_property(srna, PROP_BOOLEAN);
1271
1272         /* IntProperty */
1273         srna= RNA_def_struct(brna, "IntProperty", "Property");
1274         RNA_def_struct_ui_text(srna, "Int Definition", "RNA integer number property definition");
1275         rna_def_number_property(srna, PROP_INT);
1276
1277         /* FloatProperty */
1278         srna= RNA_def_struct(brna, "FloatProperty", "Property");
1279         RNA_def_struct_ui_text(srna, "Float Definition", "RNA floating pointer number property definition");
1280         rna_def_number_property(srna, PROP_FLOAT);
1281
1282         /* StringProperty */
1283         srna= RNA_def_struct(brna, "StringProperty", "Property");
1284         RNA_def_struct_ui_text(srna, "String Definition", "RNA text string property definition");
1285         rna_def_string_property(srna);
1286
1287         /* EnumProperty */
1288         srna= RNA_def_struct(brna, "EnumProperty", "Property");
1289         RNA_def_struct_ui_text(srna, "Enum Definition", "RNA enumeration property definition, to choose from a number of predefined options");
1290         rna_def_enum_property(brna, srna);
1291
1292         /* PointerProperty */
1293         srna= RNA_def_struct(brna, "PointerProperty", "Property");
1294         RNA_def_struct_ui_text(srna, "Pointer Definition", "RNA pointer property to point to another RNA struct");
1295         rna_def_pointer_property(srna, PROP_POINTER);
1296
1297         /* CollectionProperty */
1298         srna= RNA_def_struct(brna, "CollectionProperty", "Property");
1299         RNA_def_struct_ui_text(srna, "Collection Definition", "RNA collection property to define lists, arrays and mappings");
1300         rna_def_pointer_property(srna, PROP_COLLECTION);
1301         
1302         /* Function */
1303         rna_def_function(brna);
1304
1305         /* Blender RNA */
1306         srna= RNA_def_struct(brna, "BlenderRNA", NULL);
1307         RNA_def_struct_ui_text(srna, "Blender RNA", "Blender RNA structure definitions");
1308         RNA_def_struct_ui_icon(srna, ICON_RNA);
1309
1310         prop= RNA_def_property(srna, "structs", PROP_COLLECTION, PROP_NONE);
1311         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1312         RNA_def_property_struct_type(prop, "Struct");
1313         RNA_def_property_collection_funcs(prop, "rna_BlenderRNA_structs_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get",
1314                 /* included for speed, can be removed */
1315 #if 0
1316                         0,0,0);
1317 #else
1318                         "rna_BlenderRNA_structs_length", "rna_BlenderRNA_structs_lookup_int", "rna_BlenderRNA_structs_lookup_string");
1319 #endif
1320
1321         RNA_def_property_ui_text(prop, "Structs", "");
1322 }
1323
1324 #endif
1325