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