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