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