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