svn merge -r 21041:21301 https://svn.blender.org/svnroot/bf-blender/branches/blender2...
[blender.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);
387 }
388
389 static int rna_Property_description_length(PointerRNA *ptr)
390 {
391         PropertyRNA *prop= (PropertyRNA*)ptr->data;
392         rna_idproperty_check(&prop, ptr);
393         return strlen(prop->description);
394 }
395
396 static int rna_Property_type_get(PointerRNA *ptr)
397 {
398         PropertyRNA *prop= (PropertyRNA*)ptr->data;
399         rna_idproperty_check(&prop, ptr);
400         return prop->type;
401 }
402
403 static int rna_Property_subtype_get(PointerRNA *ptr)
404 {
405         PropertyRNA *prop= (PropertyRNA*)ptr->data;
406         rna_idproperty_check(&prop, ptr);
407         return prop->subtype;
408 }
409
410 static int rna_Property_editable_get(PointerRNA *ptr)
411 {
412         PropertyRNA *prop= (PropertyRNA*)ptr->data;
413         return RNA_property_editable(ptr, prop);
414 }
415
416 static int rna_Property_array_length_get(PointerRNA *ptr)
417 {
418         PropertyRNA *prop= (PropertyRNA*)ptr->data;
419         rna_idproperty_check(&prop, ptr);
420         return prop->arraylength;
421 }
422
423 static int rna_Property_registered_get(PointerRNA *ptr)
424 {
425         PropertyRNA *prop= (PropertyRNA*)ptr->data;
426         return prop->flag & PROP_REGISTER;
427 }
428
429 static int rna_Property_registered_optional_get(PointerRNA *ptr)
430 {
431         PropertyRNA *prop= (PropertyRNA*)ptr->data;
432         return prop->flag & PROP_REGISTER_OPTIONAL;
433 }
434
435 static int rna_IntProperty_hard_min_get(PointerRNA *ptr)
436 {
437         PropertyRNA *prop= (PropertyRNA*)ptr->data;
438         rna_idproperty_check(&prop, ptr);
439         return ((IntPropertyRNA*)prop)->hardmin;
440 }
441
442 static int rna_IntProperty_hard_max_get(PointerRNA *ptr)
443 {
444         PropertyRNA *prop= (PropertyRNA*)ptr->data;
445         rna_idproperty_check(&prop, ptr);
446         return ((IntPropertyRNA*)prop)->hardmax;
447 }
448
449 static int rna_IntProperty_soft_min_get(PointerRNA *ptr)
450 {
451         PropertyRNA *prop= (PropertyRNA*)ptr->data;
452         rna_idproperty_check(&prop, ptr);
453         return ((IntPropertyRNA*)prop)->softmin;
454 }
455
456 static int rna_IntProperty_soft_max_get(PointerRNA *ptr)
457 {
458         PropertyRNA *prop= (PropertyRNA*)ptr->data;
459         rna_idproperty_check(&prop, ptr);
460         return ((IntPropertyRNA*)prop)->softmax;
461 }
462
463 static int rna_IntProperty_step_get(PointerRNA *ptr)
464 {
465         PropertyRNA *prop= (PropertyRNA*)ptr->data;
466         rna_idproperty_check(&prop, ptr);
467         return ((IntPropertyRNA*)prop)->step;
468 }
469
470 static float rna_FloatProperty_hard_min_get(PointerRNA *ptr)
471 {
472         PropertyRNA *prop= (PropertyRNA*)ptr->data;
473         rna_idproperty_check(&prop, ptr);
474         return ((FloatPropertyRNA*)prop)->hardmin;
475 }
476
477 static float rna_FloatProperty_hard_max_get(PointerRNA *ptr)
478 {
479         PropertyRNA *prop= (PropertyRNA*)ptr->data;
480         rna_idproperty_check(&prop, ptr);
481         return ((FloatPropertyRNA*)prop)->hardmax;
482 }
483
484 static float rna_FloatProperty_soft_min_get(PointerRNA *ptr)
485 {
486         PropertyRNA *prop= (PropertyRNA*)ptr->data;
487         rna_idproperty_check(&prop, ptr);
488         return ((FloatPropertyRNA*)prop)->softmin;
489 }
490
491 static float rna_FloatProperty_soft_max_get(PointerRNA *ptr)
492 {
493         PropertyRNA *prop= (PropertyRNA*)ptr->data;
494         rna_idproperty_check(&prop, ptr);
495         return ((FloatPropertyRNA*)prop)->softmax;
496 }
497
498 static float rna_FloatProperty_step_get(PointerRNA *ptr)
499 {
500         PropertyRNA *prop= (PropertyRNA*)ptr->data;
501         rna_idproperty_check(&prop, ptr);
502         return ((FloatPropertyRNA*)prop)->step;
503 }
504
505 static int rna_FloatProperty_precision_get(PointerRNA *ptr)
506 {
507         PropertyRNA *prop= (PropertyRNA*)ptr->data;
508         rna_idproperty_check(&prop, ptr);
509         return ((FloatPropertyRNA*)prop)->precision;
510 }
511
512 static int rna_StringProperty_max_length_get(PointerRNA *ptr)
513 {
514         PropertyRNA *prop= (PropertyRNA*)ptr->data;
515         rna_idproperty_check(&prop, ptr);
516         return ((StringPropertyRNA*)prop)->maxlength;
517 }
518
519 static void rna_EnumProperty_items_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
520 {
521         PropertyRNA *prop= (PropertyRNA*)ptr->data;
522         EnumPropertyRNA *eprop;
523
524         rna_idproperty_check(&prop, ptr);
525         eprop= (EnumPropertyRNA*)prop;
526
527         rna_iterator_array_begin(iter, (void*)eprop->item, sizeof(eprop->item[0]), eprop->totitem, NULL);
528 }
529
530 static void rna_EnumPropertyItem_identifier_get(PointerRNA *ptr, char *value)
531 {
532         strcpy(value, ((EnumPropertyItem*)ptr->data)->identifier);
533 }
534
535 static int rna_EnumPropertyItem_identifier_length(PointerRNA *ptr)
536 {
537         return strlen(((EnumPropertyItem*)ptr->data)->identifier);
538 }
539
540 static void rna_EnumPropertyItem_name_get(PointerRNA *ptr, char *value)
541 {
542         strcpy(value, ((EnumPropertyItem*)ptr->data)->name);
543 }
544
545 static int rna_EnumPropertyItem_name_length(PointerRNA *ptr)
546 {
547         return strlen(((EnumPropertyItem*)ptr->data)->name);
548 }
549
550 static int rna_EnumPropertyItem_value_get(PointerRNA *ptr)
551 {
552         return ((EnumPropertyItem*)ptr->data)->value;
553 }
554
555 static PointerRNA rna_PointerProperty_fixed_type_get(PointerRNA *ptr)
556 {
557         PropertyRNA *prop= (PropertyRNA*)ptr->data;
558         rna_idproperty_check(&prop, ptr);
559         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((PointerPropertyRNA*)prop)->type);
560 }
561
562 static PointerRNA rna_CollectionProperty_fixed_type_get(PointerRNA *ptr)
563 {
564         PropertyRNA *prop= (PropertyRNA*)ptr->data;
565         rna_idproperty_check(&prop, ptr);
566         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((CollectionPropertyRNA*)prop)->type);
567 }
568
569 /* Function */
570
571 static void rna_Function_identifier_get(PointerRNA *ptr, char *value)
572 {
573         strcpy(value, ((FunctionRNA*)ptr->data)->identifier);
574 }
575
576 static int rna_Function_identifier_length(PointerRNA *ptr)
577 {
578         return strlen(((FunctionRNA*)ptr->data)->identifier);
579 }
580
581 static void rna_Function_description_get(PointerRNA *ptr, char *value)
582 {
583         strcpy(value, ((FunctionRNA*)ptr->data)->description);
584 }
585
586 static int rna_Function_description_length(PointerRNA *ptr)
587 {
588         return strlen(((FunctionRNA*)ptr->data)->description);
589 }
590
591 static void rna_Function_parameters_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
592 {
593         rna_iterator_listbase_begin(iter, &((FunctionRNA*)ptr->data)->cont.properties, rna_property_builtin);
594 }
595
596 static int rna_Function_registered_get(PointerRNA *ptr)
597 {
598         FunctionRNA *func= (FunctionRNA*)ptr->data;
599         return func->flag & FUNC_REGISTER;
600 }
601
602 static int rna_Function_registered_optional_get(PointerRNA *ptr)
603 {
604         FunctionRNA *func= (FunctionRNA*)ptr->data;
605         return func->flag & FUNC_REGISTER_OPTIONAL;
606 }
607
608 /* Blender RNA */
609
610 static void rna_BlenderRNA_structs_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
611 {
612         rna_iterator_listbase_begin(iter, &((BlenderRNA*)ptr->data)->structs, NULL);
613 }
614
615 #else
616
617 static void rna_def_struct(BlenderRNA *brna)
618 {
619         StructRNA *srna;
620         PropertyRNA *prop;
621
622         srna= RNA_def_struct(brna, "Struct", NULL);
623         RNA_def_struct_ui_text(srna, "Struct Definition", "RNA structure definition");
624         RNA_def_struct_ui_icon(srna, ICON_RNA);
625
626         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
627         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
628         RNA_def_property_string_funcs(prop, "rna_Struct_name_get", "rna_Struct_name_length", NULL);
629         RNA_def_property_ui_text(prop, "Name", "Human readable name.");
630
631         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
632         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
633         RNA_def_property_string_funcs(prop, "rna_Struct_identifier_get", "rna_Struct_identifier_length", NULL);
634         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
635         RNA_def_struct_name_property(srna, prop);
636         
637         prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
638         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
639         RNA_def_property_string_funcs(prop, "rna_Struct_description_get", "rna_Struct_description_length", NULL);
640         RNA_def_property_ui_text(prop, "Description", "Description of the Struct's purpose.");
641         
642         prop= RNA_def_property(srna, "base", PROP_POINTER, PROP_NONE);
643         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
644         RNA_def_property_struct_type(prop, "Struct");
645         RNA_def_property_pointer_funcs(prop, "rna_Struct_base_get", NULL, NULL);
646         RNA_def_property_ui_text(prop, "Base", "Struct definition this is derived from.");
647
648         prop= RNA_def_property(srna, "nested", PROP_POINTER, PROP_NONE);
649         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
650         RNA_def_property_struct_type(prop, "Struct");
651         RNA_def_property_pointer_funcs(prop, "rna_Struct_nested_get", NULL, NULL);
652         RNA_def_property_ui_text(prop, "Nested", "Struct in which this struct is always nested, and to which it logically belongs.");
653
654         prop= RNA_def_property(srna, "name_property", PROP_POINTER, PROP_NONE);
655         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
656         RNA_def_property_struct_type(prop, "StringProperty");
657         RNA_def_property_pointer_funcs(prop, "rna_Struct_name_property_get", NULL, NULL);
658         RNA_def_property_ui_text(prop, "Name Property", "Property that gives the name of the struct.");
659
660         prop= RNA_def_property(srna, "properties", PROP_COLLECTION, PROP_NONE);
661         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
662         RNA_def_property_struct_type(prop, "Property");
663         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);
664         RNA_def_property_ui_text(prop, "Properties", "Properties in the struct.");
665
666         prop= RNA_def_property(srna, "functions", PROP_COLLECTION, PROP_NONE);
667         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
668         RNA_def_property_struct_type(prop, "Function");
669         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);
670         RNA_def_property_ui_text(prop, "Functions", "");
671 }
672
673 static void rna_def_property(BlenderRNA *brna)
674 {
675         StructRNA *srna;
676         PropertyRNA *prop;
677         static EnumPropertyItem type_items[] = {
678                 {PROP_BOOLEAN, "BOOLEAN", 0, "Boolean", ""},
679                 {PROP_INT, "INT", 0, "Integer", ""},
680                 {PROP_FLOAT, "FLOAT", 0, "Float", ""},
681                 {PROP_STRING, "STRING", 0, "String", ""},
682                 {PROP_ENUM, "ENUM", 0, "Enumeration", ""},
683                 {PROP_POINTER, "POINTER", 0, "Pointer", ""},
684                 {PROP_COLLECTION, "COLLECTION", 0, "Collection", ""},
685                 {0, NULL, 0, NULL, NULL}};
686         static EnumPropertyItem subtype_items[] = {
687                 {PROP_NONE, "NONE", 0, "None", ""},
688                 {PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned Number", ""},
689                 {PROP_FILEPATH, "FILE_PATH", 0, "File Path", ""},
690                 {PROP_DIRPATH, "DIRECTORY_PATH", 0, "Directory Path", ""},
691                 {PROP_COLOR, "COLOR", 0, "Color", ""},
692                 {PROP_VECTOR, "VECTOR", 0, "Vector", ""},
693                 {PROP_MATRIX, "MATRIX", 0, "Matrix", ""},
694                 {PROP_ROTATION, "ROTATION", 0, "Rotation", ""},
695                 {PROP_NEVER_NULL, "NEVER_NULL", 0, "Never Null", ""},
696                 {PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", ""},
697                 {0, NULL, 0, NULL, NULL}};
698
699         srna= RNA_def_struct(brna, "Property", NULL);
700         RNA_def_struct_ui_text(srna, "Property Definition", "RNA property definition.");
701         RNA_def_struct_refine_func(srna, "rna_Property_refine");
702         RNA_def_struct_ui_icon(srna, ICON_RNA);
703
704         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
705         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
706         RNA_def_property_string_funcs(prop, "rna_Property_name_get", "rna_Property_name_length", NULL);
707         RNA_def_property_ui_text(prop, "Name", "Human readable name.");
708
709         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
710         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
711         RNA_def_property_string_funcs(prop, "rna_Property_identifier_get", "rna_Property_identifier_length", NULL);
712         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
713         RNA_def_struct_name_property(srna, prop);
714                 
715         prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
716         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
717         RNA_def_property_string_funcs(prop, "rna_Property_description_get", "rna_Property_description_length", NULL);
718         RNA_def_property_ui_text(prop, "Description", "Description of the property for tooltips.");
719
720         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
721         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
722         RNA_def_property_enum_items(prop, type_items);
723         RNA_def_property_enum_funcs(prop, "rna_Property_type_get", NULL, NULL);
724         RNA_def_property_ui_text(prop, "Type", "Data type of the property.");
725
726         prop= RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
727         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
728         RNA_def_property_enum_items(prop, subtype_items);
729         RNA_def_property_enum_funcs(prop, "rna_Property_subtype_get", NULL, NULL);
730         RNA_def_property_ui_text(prop, "Subtype", "Semantic interpretation of the property.");
731
732         prop= RNA_def_property(srna, "editable", PROP_BOOLEAN, PROP_NONE);
733         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
734         RNA_def_property_boolean_funcs(prop, "rna_Property_editable_get", NULL);
735         RNA_def_property_ui_text(prop, "Editable", "Property is editable through RNA.");
736
737         prop= RNA_def_property(srna, "registered", PROP_BOOLEAN, PROP_NONE);
738         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
739         RNA_def_property_boolean_funcs(prop, "rna_Property_registered_get", NULL);
740         RNA_def_property_ui_text(prop, "Registered", "Property is registerd as part of type registration.");
741
742         prop= RNA_def_property(srna, "registered_optional", PROP_BOOLEAN, PROP_NONE);
743         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
744         RNA_def_property_boolean_funcs(prop, "rna_Property_registered_optional_get", NULL);
745         RNA_def_property_ui_text(prop, "Registered Optionally", "Property is optionally registerd as part of type registration.");
746 }
747
748 static void rna_def_function(BlenderRNA *brna)
749 {
750         StructRNA *srna;
751         PropertyRNA *prop;
752
753         srna= RNA_def_struct(brna, "Function", NULL);
754         RNA_def_struct_ui_text(srna, "Function Definition", "RNA function definition");
755         RNA_def_struct_ui_icon(srna, ICON_RNA);
756
757         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
758         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
759         RNA_def_property_string_funcs(prop, "rna_Function_identifier_get", "rna_Function_identifier_length", NULL);
760         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
761         RNA_def_struct_name_property(srna, prop);
762
763         prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
764         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
765         RNA_def_property_string_funcs(prop, "rna_Function_description_get", "rna_Function_description_length", NULL);
766         RNA_def_property_ui_text(prop, "Description", "Description of the Function's purpose.");
767
768         prop= RNA_def_property(srna, "parameters", PROP_COLLECTION, PROP_NONE);
769         /*RNA_def_property_clear_flag(prop, PROP_EDITABLE);*/
770         RNA_def_property_struct_type(prop, "Property");
771         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);
772         RNA_def_property_ui_text(prop, "Parameters", "Parameters for the function.");
773
774         prop= RNA_def_property(srna, "registered", PROP_BOOLEAN, PROP_NONE);
775         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
776         RNA_def_property_boolean_funcs(prop, "rna_Function_registered_get", NULL);
777         RNA_def_property_ui_text(prop, "Registered", "Function is registerd as callback as part of type registration.");
778
779         prop= RNA_def_property(srna, "registered_optional", PROP_BOOLEAN, PROP_NONE);
780         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
781         RNA_def_property_boolean_funcs(prop, "rna_Function_registered_optional_get", NULL);
782         RNA_def_property_ui_text(prop, "Registered Optionally", "Function is optionally registerd as callback part of type registration.");
783 }
784
785 static void rna_def_number_property(StructRNA *srna, PropertyType type)
786 {
787         PropertyRNA *prop;
788
789         prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_UNSIGNED);
790         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
791         RNA_def_property_int_funcs(prop, "rna_Property_array_length_get", NULL, NULL);
792         RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited.");
793
794         if(type == PROP_BOOLEAN)
795                 return;
796
797         prop= RNA_def_property(srna, "hard_min", type, PROP_NONE);
798         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
799         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_min_get", NULL, NULL);
800         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_min_get", NULL, NULL);
801         RNA_def_property_ui_text(prop, "Hard Minimum", "Minimum value used by buttons.");
802
803         prop= RNA_def_property(srna, "hard_max", type, PROP_NONE);
804         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
805         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_max_get", NULL, NULL);
806         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_max_get", NULL, NULL);
807         RNA_def_property_ui_text(prop, "Hard Maximum", "Maximum value used by buttons.");
808
809         prop= RNA_def_property(srna, "soft_min", type, PROP_NONE);
810         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
811         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_min_get", NULL, NULL);
812         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_min_get", NULL, NULL);
813         RNA_def_property_ui_text(prop, "Soft Minimum", "Minimum value used by buttons.");
814
815         prop= RNA_def_property(srna, "soft_max", type, PROP_NONE);
816         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
817         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_max_get", NULL, NULL);
818         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_max_get", NULL, NULL);
819         RNA_def_property_ui_text(prop, "Soft Maximum", "Maximum value used by buttons.");
820
821         prop= RNA_def_property(srna, "step", type, PROP_UNSIGNED);
822         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
823         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_step_get", NULL, NULL);
824         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_step_get", NULL, NULL);
825         RNA_def_property_ui_text(prop, "Step", "Step size used by number buttons, for floats 1/100th of the step size.");
826
827         if(type == PROP_FLOAT) {
828                 prop= RNA_def_property(srna, "precision", PROP_INT, PROP_UNSIGNED);
829                 RNA_def_property_clear_flag(prop, PROP_EDITABLE);
830                 RNA_def_property_int_funcs(prop, "rna_FloatProperty_precision_get", NULL, NULL);
831                 RNA_def_property_ui_text(prop, "Precision", "Number of digits after the dot used by buttons.");
832         }
833 }
834
835 static void rna_def_string_property(StructRNA *srna)
836 {
837         PropertyRNA *prop;
838
839         prop= RNA_def_property(srna, "max_length", PROP_INT, PROP_UNSIGNED);
840         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
841         RNA_def_property_int_funcs(prop, "rna_StringProperty_max_length_get", NULL, NULL);
842         RNA_def_property_ui_text(prop, "Maximum Length", "Maximum length of the string, 0 means unlimited.");
843 }
844
845 static void rna_def_enum_property(BlenderRNA *brna, StructRNA *srna)
846 {
847         PropertyRNA *prop;
848
849         prop= RNA_def_property(srna, "items", PROP_COLLECTION, PROP_NONE);
850         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
851         RNA_def_property_struct_type(prop, "EnumPropertyItem");
852         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);
853         RNA_def_property_ui_text(prop, "Items", "Possible values for the property.");
854
855         srna= RNA_def_struct(brna, "EnumPropertyItem", NULL);
856         RNA_def_struct_ui_text(srna, "Enum Item Definition", "Definition of a choice in an RNA enum property.");
857         RNA_def_struct_ui_icon(srna, ICON_RNA);
858
859         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
860         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
861         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_name_get", "rna_EnumPropertyItem_name_length", NULL);
862         RNA_def_property_ui_text(prop, "Name", "Human readable name.");
863
864         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
865         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
866         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_identifier_get", "rna_EnumPropertyItem_identifier_length", NULL);
867         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
868         RNA_def_struct_name_property(srna, prop);
869
870         prop= RNA_def_property(srna, "value", PROP_INT, PROP_UNSIGNED);
871         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
872         RNA_def_property_int_funcs(prop, "rna_EnumPropertyItem_value_get", NULL, NULL);
873         RNA_def_property_ui_text(prop, "Value", "Value of the item.");
874 }
875
876 static void rna_def_pointer_property(StructRNA *srna, PropertyType type)
877 {
878         PropertyRNA *prop;
879
880         prop= RNA_def_property(srna, "fixed_type", PROP_POINTER, PROP_NONE);
881         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
882         RNA_def_property_struct_type(prop, "Struct");
883         if(type == PROP_POINTER)
884                 RNA_def_property_pointer_funcs(prop, "rna_PointerProperty_fixed_type_get", NULL, NULL);
885         else
886                 RNA_def_property_pointer_funcs(prop, "rna_CollectionProperty_fixed_type_get", NULL, NULL);
887         RNA_def_property_ui_text(prop, "Pointer Type", "Fixed pointer type, empty if variable type.");
888 }
889
890 void RNA_def_rna(BlenderRNA *brna)
891 {
892         StructRNA *srna;
893         PropertyRNA *prop;
894
895         /* Struct*/
896         rna_def_struct(brna);
897
898         /* Property */
899         rna_def_property(brna);
900
901         /* BooleanProperty */
902         srna= RNA_def_struct(brna, "BooleanProperty", "Property");
903         RNA_def_struct_ui_text(srna, "Boolean Definition", "RNA boolean property definition.");
904         rna_def_number_property(srna, PROP_BOOLEAN);
905
906         /* IntProperty */
907         srna= RNA_def_struct(brna, "IntProperty", "Property");
908         RNA_def_struct_ui_text(srna, "Int Definition", "RNA integer number property definition.");
909         rna_def_number_property(srna, PROP_INT);
910
911         /* FloatProperty */
912         srna= RNA_def_struct(brna, "FloatProperty", "Property");
913         RNA_def_struct_ui_text(srna, "Float Definition", "RNA floating pointer number property definition.");
914         rna_def_number_property(srna, PROP_FLOAT);
915
916         /* StringProperty */
917         srna= RNA_def_struct(brna, "StringProperty", "Property");
918         RNA_def_struct_ui_text(srna, "String Definition", "RNA text string property definition.");
919         rna_def_string_property(srna);
920
921         /* EnumProperty */
922         srna= RNA_def_struct(brna, "EnumProperty", "Property");
923         RNA_def_struct_ui_text(srna, "Enum Definition", "RNA enumeration property definition, to choose from a number of predefined options.");
924         rna_def_enum_property(brna, srna);
925
926         /* PointerProperty */
927         srna= RNA_def_struct(brna, "PointerProperty", "Property");
928         RNA_def_struct_ui_text(srna, "Pointer Definition", "RNA pointer property to point to another RNA struct.");
929         rna_def_pointer_property(srna, PROP_POINTER);
930
931         /* CollectionProperty */
932         srna= RNA_def_struct(brna, "CollectionProperty", "Property");
933         RNA_def_struct_ui_text(srna, "Collection Definition", "RNA collection property to define lists, arrays and mappings.");
934         rna_def_pointer_property(srna, PROP_COLLECTION);
935         
936         /* Function */
937         rna_def_function(brna);
938
939         /* Blender RNA */
940         srna= RNA_def_struct(brna, "BlenderRNA", NULL);
941         RNA_def_struct_ui_text(srna, "Blender RNA", "Blender RNA structure definitions.");
942         RNA_def_struct_ui_icon(srna, ICON_RNA);
943
944         prop= RNA_def_property(srna, "structs", PROP_COLLECTION, PROP_NONE);
945         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
946         RNA_def_property_struct_type(prop, "Struct");
947         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);
948         RNA_def_property_ui_text(prop, "Structs", "");
949 }
950
951 #endif
952