RNA
[blender-staging.git] / source / blender / makesrna / intern / rna_rna.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * Contributor(s): Blender Foundation (2008).
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26
27 #include "DNA_ID.h"
28
29 #include "RNA_access.h"
30 #include "RNA_define.h"
31 #include "RNA_types.h"
32
33 #include "rna_internal.h"
34
35 #ifdef RNA_RUNTIME
36
37 /* Struct */
38
39 static void rna_Struct_identifier_get(PointerRNA *ptr, char *value)
40 {
41         strcpy(value, ((StructRNA*)ptr->data)->identifier);
42 }
43
44 static int rna_Struct_identifier_length(PointerRNA *ptr)
45 {
46         return strlen(((StructRNA*)ptr->data)->identifier);
47 }
48
49 static void rna_Struct_description_get(PointerRNA *ptr, char *value)
50 {
51         strcpy(value, ((StructRNA*)ptr->data)->description);
52 }
53
54 static int rna_Struct_description_length(PointerRNA *ptr)
55 {
56         return strlen(((StructRNA*)ptr->data)->description);
57 }
58
59 static void rna_Struct_name_get(PointerRNA *ptr, char *value)
60 {
61         strcpy(value, ((StructRNA*)ptr->data)->name);
62 }
63
64 static int rna_Struct_name_length(PointerRNA *ptr)
65 {
66         return strlen(((StructRNA*)ptr->data)->name);
67 }
68
69 static PointerRNA rna_Struct_base_get(PointerRNA *ptr)
70 {
71         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((StructRNA*)ptr->data)->base);
72 }
73
74 static PointerRNA rna_Struct_nested_get(PointerRNA *ptr)
75 {
76         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((StructRNA*)ptr->data)->nested);
77 }
78
79 static PointerRNA rna_Struct_name_property_get(PointerRNA *ptr)
80 {
81         return rna_pointer_inherit_refine(ptr, &RNA_Property, ((StructRNA*)ptr->data)->nameproperty);
82 }
83
84 /* Struct property iteration. This is quite complicated, the purpose is to
85  * iterate over properties of all inheritance levels, and for each struct to
86  * also iterator over id properties not known by RNA. */
87
88 static int rna_idproperty_known(CollectionPropertyIterator *iter, void *data)
89 {
90         IDProperty *idprop= (IDProperty*)data;
91         PropertyRNA *prop;
92         StructRNA *ptype= iter->builtin_parent.type;
93
94         /* function to skip any id properties that are already known by RNA,
95          * for the second loop where we go over unknown id properties */
96
97         for(prop= ptype->cont.properties.first; prop; prop=prop->next)
98                 if(strcmp(prop->identifier, idprop->name) == 0)
99                         return 1;
100         
101         return 0;
102 }
103
104 static int rna_property_builtin(CollectionPropertyIterator *iter, void *data)
105 {
106         PropertyRNA *prop= (PropertyRNA*)data;
107
108         /* function to skip builtin rna properties */
109
110         return (prop->flag & PROP_BUILTIN);
111 }
112
113 static int rna_function_builtin(CollectionPropertyIterator *iter, void *data)
114 {
115         FunctionRNA *func= (FunctionRNA*)data;
116
117         /* function to skip builtin rna functions */
118
119         return (func->flag & FUNC_BUILTIN);
120 }
121
122 static void rna_inheritance_next_level_restart(CollectionPropertyIterator *iter, IteratorSkipFunc skip, int funcs)
123 {
124         /* RNA struct inheritance */
125         while(!iter->valid && iter->level > 0) {
126                 StructRNA *srna;
127                 int i;
128
129                 srna= (StructRNA*)iter->parent.data;
130                 iter->level--;
131                 for(i=iter->level; i>0; i--)
132                         srna= srna->base;
133
134                 rna_iterator_listbase_end(iter);
135
136                 if (funcs)
137                         rna_iterator_listbase_begin(iter, &srna->functions, skip);
138                 else
139                         rna_iterator_listbase_begin(iter, &srna->cont.properties, skip);
140         }
141 }
142
143 static void rna_inheritance_properties_listbase_begin(CollectionPropertyIterator *iter, ListBase *lb, IteratorSkipFunc skip)
144 {
145         rna_iterator_listbase_begin(iter, lb, skip);
146         rna_inheritance_next_level_restart(iter, skip, 0);
147 }
148
149 static void rna_inheritance_properties_listbase_next(CollectionPropertyIterator *iter, IteratorSkipFunc skip)
150 {
151         rna_iterator_listbase_next(iter);
152         rna_inheritance_next_level_restart(iter, skip, 0);
153 }
154
155 static void rna_inheritance_functions_listbase_begin(CollectionPropertyIterator *iter, ListBase *lb, IteratorSkipFunc skip)
156 {
157         rna_iterator_listbase_begin(iter, lb, skip);
158         rna_inheritance_next_level_restart(iter, skip, 1);
159 }
160
161 static void rna_inheritance_functions_listbase_next(CollectionPropertyIterator *iter, IteratorSkipFunc skip)
162 {
163         rna_iterator_listbase_next(iter);
164         rna_inheritance_next_level_restart(iter, skip, 1);
165 }
166
167 static void rna_Struct_properties_next(CollectionPropertyIterator *iter)
168 {
169         ListBaseIterator *internal= iter->internal;
170         IDProperty *group;
171
172         if(internal->flag) {
173                 /* id properties */
174                 rna_iterator_listbase_next(iter);
175         }
176         else {
177                 /* regular properties */
178                 rna_inheritance_properties_listbase_next(iter, rna_property_builtin);
179
180                 /* try id properties */
181                 if(!iter->valid) {
182                         group= RNA_struct_idproperties(&iter->builtin_parent, 0);
183
184                         if(group) {
185                                 rna_iterator_listbase_end(iter);
186                                 rna_iterator_listbase_begin(iter, &group->data.group, rna_idproperty_known);
187                                 internal= iter->internal;
188                                 internal->flag= 1;
189                         }
190                 }
191         }
192 }
193
194 static void rna_Struct_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
195 {
196         StructRNA *srna;
197
198         /* here ptr->data should always be the same as iter->parent.type */
199         srna= (StructRNA *)ptr->data;
200
201         while(srna->base) {
202                 iter->level++;
203                 srna= srna->base;
204         }
205
206         rna_inheritance_properties_listbase_begin(iter, &srna->cont.properties, rna_property_builtin);
207 }
208
209 static PointerRNA rna_Struct_properties_get(CollectionPropertyIterator *iter)
210 {
211         ListBaseIterator *internal= iter->internal;
212
213         /* we return either PropertyRNA* or IDProperty*, the rna_access.c
214          * functions can handle both as PropertyRNA* with some tricks */
215         return rna_pointer_inherit_refine(&iter->parent, &RNA_Property, internal->link);
216 }
217
218 static void rna_Struct_functions_next(CollectionPropertyIterator *iter)
219 {
220         rna_inheritance_functions_listbase_next(iter, rna_function_builtin);
221 }
222
223 static void rna_Struct_functions_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
224 {
225         StructRNA *srna;
226
227         /* here ptr->data should always be the same as iter->parent.type */
228         srna= (StructRNA *)ptr->data;
229
230         while(srna->base) {
231                 iter->level++;
232                 srna= srna->base;
233         }
234
235         rna_inheritance_functions_listbase_begin(iter, &srna->functions, rna_function_builtin);
236 }
237
238 static PointerRNA rna_Struct_functions_get(CollectionPropertyIterator *iter)
239 {
240         ListBaseIterator *internal= iter->internal;
241
242         /* we return either PropertyRNA* or IDProperty*, the rna_access.c
243          * functions can handle both as PropertyRNA* with some tricks */
244         return rna_pointer_inherit_refine(&iter->parent, &RNA_Function, internal->link);
245 }
246
247 /* Builtin properties iterator re-uses the Struct properties iterator, only
248  * difference is that we need to set the ptr data to the type of the struct
249  * whose properties we want to iterate over. */
250
251 void rna_builtin_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
252 {
253         PointerRNA newptr;
254
255         /* we create a new pointer with the type as the data */
256         newptr.type= &RNA_Struct;
257         newptr.data= ptr->type;
258
259         if(ptr->type->flag & STRUCT_ID)
260                 newptr.id.data= ptr->data;
261         else
262                 newptr.id.data= NULL;
263
264         iter->parent= newptr;
265         iter->builtin_parent = *ptr;
266
267         rna_Struct_properties_begin(iter, &newptr);
268 }
269
270 void rna_builtin_properties_next(CollectionPropertyIterator *iter)
271 {
272         rna_Struct_properties_next(iter);
273 }
274
275 PointerRNA rna_builtin_properties_get(CollectionPropertyIterator *iter)
276 {
277         return rna_Struct_properties_get(iter);
278 }
279
280 PointerRNA rna_builtin_type_get(PointerRNA *ptr)
281 {
282         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ptr->type);
283 }
284
285 /* Property */
286
287 static StructRNA *rna_Property_refine(PointerRNA *ptr)
288 {
289         PropertyRNA *prop= (PropertyRNA*)ptr->data;
290
291         rna_idproperty_check(&prop, ptr); /* XXX ptr? */
292
293         switch(prop->type) {
294                 case PROP_BOOLEAN: return &RNA_BooleanProperty;
295                 case PROP_INT: return &RNA_IntProperty;
296                 case PROP_FLOAT: return &RNA_FloatProperty;
297                 case PROP_STRING: return &RNA_StringProperty;
298                 case PROP_ENUM: return &RNA_EnumProperty;
299                 case PROP_POINTER: return &RNA_PointerProperty;
300                 case PROP_COLLECTION: return &RNA_CollectionProperty;
301                 default: return &RNA_Property;
302         }
303 }
304
305 static void rna_Property_identifier_get(PointerRNA *ptr, char *value)
306 {
307         PropertyRNA *prop= (PropertyRNA*)ptr->data;
308         rna_idproperty_check(&prop, ptr);
309         strcpy(value, ((PropertyRNA*)prop)->identifier);
310 }
311
312 static int rna_Property_identifier_length(PointerRNA *ptr)
313 {
314         PropertyRNA *prop= (PropertyRNA*)ptr->data;
315         rna_idproperty_check(&prop, ptr);
316         return strlen(prop->identifier);
317 }
318
319 static void rna_Property_name_get(PointerRNA *ptr, char *value)
320 {
321         PropertyRNA *prop= (PropertyRNA*)ptr->data;
322         rna_idproperty_check(&prop, ptr);
323         strcpy(value, prop->name);
324 }
325
326 static int rna_Property_name_length(PointerRNA *ptr)
327 {
328         PropertyRNA *prop= (PropertyRNA*)ptr->data;
329         rna_idproperty_check(&prop, ptr);
330         return strlen(prop->name);
331 }
332
333 static void rna_Property_description_get(PointerRNA *ptr, char *value)
334 {
335         PropertyRNA *prop= (PropertyRNA*)ptr->data;
336         rna_idproperty_check(&prop, ptr);
337         strcpy(value, prop->description);
338 }
339
340 static int rna_Property_description_length(PointerRNA *ptr)
341 {
342         PropertyRNA *prop= (PropertyRNA*)ptr->data;
343         rna_idproperty_check(&prop, ptr);
344         return strlen(prop->description);
345 }
346
347 static int rna_Property_type_get(PointerRNA *ptr)
348 {
349         PropertyRNA *prop= (PropertyRNA*)ptr->data;
350         rna_idproperty_check(&prop, ptr);
351         return prop->type;
352 }
353
354 static int rna_Property_subtype_get(PointerRNA *ptr)
355 {
356         PropertyRNA *prop= (PropertyRNA*)ptr->data;
357         rna_idproperty_check(&prop, ptr);
358         return prop->subtype;
359 }
360
361 static int rna_Property_editable_get(PointerRNA *ptr)
362 {
363         PropertyRNA *prop= (PropertyRNA*)ptr->data;
364         return RNA_property_editable(ptr, prop);
365 }
366
367 static int rna_Property_array_length_get(PointerRNA *ptr)
368 {
369         PropertyRNA *prop= (PropertyRNA*)ptr->data;
370         rna_idproperty_check(&prop, ptr);
371         return prop->arraylength;
372 }
373
374 static int rna_Property_registered_get(PointerRNA *ptr)
375 {
376         PropertyRNA *prop= (PropertyRNA*)ptr->data;
377         return prop->flag & PROP_REGISTER;
378 }
379
380 static int rna_Property_registered_optional_get(PointerRNA *ptr)
381 {
382         PropertyRNA *prop= (PropertyRNA*)ptr->data;
383         return prop->flag & PROP_REGISTER_OPTIONAL;
384 }
385
386 static int rna_IntProperty_hard_min_get(PointerRNA *ptr)
387 {
388         PropertyRNA *prop= (PropertyRNA*)ptr->data;
389         rna_idproperty_check(&prop, ptr);
390         return ((IntPropertyRNA*)prop)->hardmin;
391 }
392
393 static int rna_IntProperty_hard_max_get(PointerRNA *ptr)
394 {
395         PropertyRNA *prop= (PropertyRNA*)ptr->data;
396         rna_idproperty_check(&prop, ptr);
397         return ((IntPropertyRNA*)prop)->hardmax;
398 }
399
400 static int rna_IntProperty_soft_min_get(PointerRNA *ptr)
401 {
402         PropertyRNA *prop= (PropertyRNA*)ptr->data;
403         rna_idproperty_check(&prop, ptr);
404         return ((IntPropertyRNA*)prop)->softmin;
405 }
406
407 static int rna_IntProperty_soft_max_get(PointerRNA *ptr)
408 {
409         PropertyRNA *prop= (PropertyRNA*)ptr->data;
410         rna_idproperty_check(&prop, ptr);
411         return ((IntPropertyRNA*)prop)->softmax;
412 }
413
414 static int rna_IntProperty_step_get(PointerRNA *ptr)
415 {
416         PropertyRNA *prop= (PropertyRNA*)ptr->data;
417         rna_idproperty_check(&prop, ptr);
418         return ((IntPropertyRNA*)prop)->step;
419 }
420
421 static float rna_FloatProperty_hard_min_get(PointerRNA *ptr)
422 {
423         PropertyRNA *prop= (PropertyRNA*)ptr->data;
424         rna_idproperty_check(&prop, ptr);
425         return ((FloatPropertyRNA*)prop)->hardmin;
426 }
427
428 static float rna_FloatProperty_hard_max_get(PointerRNA *ptr)
429 {
430         PropertyRNA *prop= (PropertyRNA*)ptr->data;
431         rna_idproperty_check(&prop, ptr);
432         return ((FloatPropertyRNA*)prop)->hardmax;
433 }
434
435 static float rna_FloatProperty_soft_min_get(PointerRNA *ptr)
436 {
437         PropertyRNA *prop= (PropertyRNA*)ptr->data;
438         rna_idproperty_check(&prop, ptr);
439         return ((FloatPropertyRNA*)prop)->softmin;
440 }
441
442 static float rna_FloatProperty_soft_max_get(PointerRNA *ptr)
443 {
444         PropertyRNA *prop= (PropertyRNA*)ptr->data;
445         rna_idproperty_check(&prop, ptr);
446         return ((FloatPropertyRNA*)prop)->softmax;
447 }
448
449 static float rna_FloatProperty_step_get(PointerRNA *ptr)
450 {
451         PropertyRNA *prop= (PropertyRNA*)ptr->data;
452         rna_idproperty_check(&prop, ptr);
453         return ((FloatPropertyRNA*)prop)->step;
454 }
455
456 static int rna_FloatProperty_precision_get(PointerRNA *ptr)
457 {
458         PropertyRNA *prop= (PropertyRNA*)ptr->data;
459         rna_idproperty_check(&prop, ptr);
460         return ((FloatPropertyRNA*)prop)->precision;
461 }
462
463 static int rna_StringProperty_max_length_get(PointerRNA *ptr)
464 {
465         PropertyRNA *prop= (PropertyRNA*)ptr->data;
466         rna_idproperty_check(&prop, ptr);
467         return ((StringPropertyRNA*)prop)->maxlength;
468 }
469
470 static void rna_EnumProperty_items_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
471 {
472         PropertyRNA *prop= (PropertyRNA*)ptr->data;
473         EnumPropertyRNA *eprop;
474
475         rna_idproperty_check(&prop, ptr);
476         eprop= (EnumPropertyRNA*)prop;
477
478         rna_iterator_array_begin(iter, (void*)eprop->item, sizeof(eprop->item[0]), eprop->totitem, NULL);
479 }
480
481 static void rna_EnumPropertyItem_identifier_get(PointerRNA *ptr, char *value)
482 {
483         strcpy(value, ((EnumPropertyItem*)ptr->data)->identifier);
484 }
485
486 static int rna_EnumPropertyItem_identifier_length(PointerRNA *ptr)
487 {
488         return strlen(((EnumPropertyItem*)ptr->data)->identifier);
489 }
490
491 static void rna_EnumPropertyItem_name_get(PointerRNA *ptr, char *value)
492 {
493         strcpy(value, ((EnumPropertyItem*)ptr->data)->name);
494 }
495
496 static int rna_EnumPropertyItem_name_length(PointerRNA *ptr)
497 {
498         return strlen(((EnumPropertyItem*)ptr->data)->name);
499 }
500
501 static int rna_EnumPropertyItem_value_get(PointerRNA *ptr)
502 {
503         return ((EnumPropertyItem*)ptr->data)->value;
504 }
505
506 static PointerRNA rna_PointerProperty_fixed_type_get(PointerRNA *ptr)
507 {
508         PropertyRNA *prop= (PropertyRNA*)ptr->data;
509         rna_idproperty_check(&prop, ptr);
510         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((PointerPropertyRNA*)prop)->type);
511 }
512
513 static PointerRNA rna_CollectionProperty_fixed_type_get(PointerRNA *ptr)
514 {
515         PropertyRNA *prop= (PropertyRNA*)ptr->data;
516         rna_idproperty_check(&prop, ptr);
517         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((CollectionPropertyRNA*)prop)->type);
518 }
519
520 /* Function */
521
522 static void rna_Function_identifier_get(PointerRNA *ptr, char *value)
523 {
524         strcpy(value, ((FunctionRNA*)ptr->data)->identifier);
525 }
526
527 static int rna_Function_identifier_length(PointerRNA *ptr)
528 {
529         return strlen(((FunctionRNA*)ptr->data)->identifier);
530 }
531
532 static void rna_Function_description_get(PointerRNA *ptr, char *value)
533 {
534         strcpy(value, ((FunctionRNA*)ptr->data)->description);
535 }
536
537 static int rna_Function_description_length(PointerRNA *ptr)
538 {
539         return strlen(((FunctionRNA*)ptr->data)->description);
540 }
541
542 static void rna_Function_parameters_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
543 {
544         rna_iterator_listbase_begin(iter, &((FunctionRNA*)ptr->data)->cont.properties, rna_property_builtin);
545 }
546
547 static int rna_Function_registered_get(PointerRNA *ptr)
548 {
549         FunctionRNA *func= (FunctionRNA*)ptr->data;
550         return func->flag & FUNC_REGISTER;
551 }
552
553 static int rna_Function_registered_optional_get(PointerRNA *ptr)
554 {
555         FunctionRNA *func= (FunctionRNA*)ptr->data;
556         return func->flag & FUNC_REGISTER_OPTIONAL;
557 }
558
559 /* Blender RNA */
560
561 static void rna_BlenderRNA_structs_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
562 {
563         rna_iterator_listbase_begin(iter, &((BlenderRNA*)ptr->data)->structs, NULL);
564 }
565
566 #else
567
568 static void rna_def_struct(BlenderRNA *brna)
569 {
570         StructRNA *srna;
571         PropertyRNA *prop;
572
573         srna= RNA_def_struct(brna, "Struct", NULL);
574         RNA_def_struct_ui_text(srna, "Struct Definition", "RNA structure definition");
575         RNA_def_struct_ui_icon(srna, ICON_RNA);
576
577         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
578         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
579         RNA_def_property_string_funcs(prop, "rna_Struct_name_get", "rna_Struct_name_length", NULL);
580         RNA_def_property_ui_text(prop, "Name", "Human readable name.");
581
582         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
583         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
584         RNA_def_property_string_funcs(prop, "rna_Struct_identifier_get", "rna_Struct_identifier_length", NULL);
585         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
586         RNA_def_struct_name_property(srna, prop);
587         
588         prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
589         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
590         RNA_def_property_string_funcs(prop, "rna_Struct_description_get", "rna_Struct_description_length", NULL);
591         RNA_def_property_ui_text(prop, "Description", "Description of the Struct's purpose.");
592         
593         prop= RNA_def_property(srna, "base", PROP_POINTER, PROP_NONE);
594         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
595         RNA_def_property_struct_type(prop, "Struct");
596         RNA_def_property_pointer_funcs(prop, "rna_Struct_base_get", NULL, NULL);
597         RNA_def_property_ui_text(prop, "Base", "Struct definition this is derived from.");
598
599         prop= RNA_def_property(srna, "nested", PROP_POINTER, PROP_NONE);
600         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
601         RNA_def_property_struct_type(prop, "Struct");
602         RNA_def_property_pointer_funcs(prop, "rna_Struct_nested_get", NULL, NULL);
603         RNA_def_property_ui_text(prop, "Nested", "Struct in which this struct is always nested, and to which it logically belongs.");
604
605         prop= RNA_def_property(srna, "name_property", PROP_POINTER, PROP_NONE);
606         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
607         RNA_def_property_struct_type(prop, "StringProperty");
608         RNA_def_property_pointer_funcs(prop, "rna_Struct_name_property_get", NULL, NULL);
609         RNA_def_property_ui_text(prop, "Name Property", "Property that gives the name of the struct.");
610
611         prop= RNA_def_property(srna, "properties", PROP_COLLECTION, PROP_NONE);
612         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
613         RNA_def_property_struct_type(prop, "Property");
614         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);
615         RNA_def_property_ui_text(prop, "Properties", "Properties in the struct.");
616
617         prop= RNA_def_property(srna, "functions", PROP_COLLECTION, PROP_NONE);
618         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
619         RNA_def_property_struct_type(prop, "Function");
620         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);
621         RNA_def_property_ui_text(prop, "Functions", "");
622 }
623
624 static void rna_def_property(BlenderRNA *brna)
625 {
626         StructRNA *srna;
627         PropertyRNA *prop;
628         static EnumPropertyItem type_items[] = {
629                 {PROP_BOOLEAN, "BOOLEAN", 0, "Boolean", ""},
630                 {PROP_INT, "INT", 0, "Integer", ""},
631                 {PROP_FLOAT, "FLOAT", 0, "Float", ""},
632                 {PROP_STRING, "STRING", 0, "String", ""},
633                 {PROP_ENUM, "ENUM", 0, "Enumeration", ""},
634                 {PROP_POINTER, "POINTER", 0, "Pointer", ""},
635                 {PROP_COLLECTION, "COLLECTION", 0, "Collection", ""},
636                 {0, NULL, 0, NULL, NULL}};
637         static EnumPropertyItem subtype_items[] = {
638                 {PROP_NONE, "NONE", 0, "None", ""},
639                 {PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned Number", ""},
640                 {PROP_FILEPATH, "FILE_PATH", 0, "File Path", ""},
641                 {PROP_DIRPATH, "DIRECTORY_PATH", 0, "Directory Path", ""},
642                 {PROP_COLOR, "COLOR", 0, "Color", ""},
643                 {PROP_VECTOR, "VECTOR", 0, "Vector", ""},
644                 {PROP_MATRIX, "MATRIX", 0, "Matrix", ""},
645                 {PROP_ROTATION, "ROTATION", 0, "Rotation", ""},
646                 {PROP_NEVER_NULL, "NEVER_NULL", 0, "Never Null", ""},
647                 {PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", ""},
648                 {0, NULL, 0, NULL, NULL}};
649
650         srna= RNA_def_struct(brna, "Property", NULL);
651         RNA_def_struct_ui_text(srna, "Property Definition", "RNA property definition.");
652         RNA_def_struct_refine_func(srna, "rna_Property_refine");
653         RNA_def_struct_ui_icon(srna, ICON_RNA);
654
655         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
656         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
657         RNA_def_property_string_funcs(prop, "rna_Property_name_get", "rna_Property_name_length", NULL);
658         RNA_def_property_ui_text(prop, "Name", "Human readable name.");
659
660         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
661         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
662         RNA_def_property_string_funcs(prop, "rna_Property_identifier_get", "rna_Property_identifier_length", NULL);
663         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
664         RNA_def_struct_name_property(srna, prop);
665                 
666         prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
667         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
668         RNA_def_property_string_funcs(prop, "rna_Property_description_get", "rna_Property_description_length", NULL);
669         RNA_def_property_ui_text(prop, "Description", "Description of the property for tooltips.");
670
671         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
672         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
673         RNA_def_property_enum_items(prop, type_items);
674         RNA_def_property_enum_funcs(prop, "rna_Property_type_get", NULL, NULL);
675         RNA_def_property_ui_text(prop, "Type", "Data type of the property.");
676
677         prop= RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
678         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
679         RNA_def_property_enum_items(prop, subtype_items);
680         RNA_def_property_enum_funcs(prop, "rna_Property_subtype_get", NULL, NULL);
681         RNA_def_property_ui_text(prop, "Subtype", "Semantic interpretation of the property.");
682
683         prop= RNA_def_property(srna, "editable", PROP_BOOLEAN, PROP_NONE);
684         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
685         RNA_def_property_boolean_funcs(prop, "rna_Property_editable_get", NULL);
686         RNA_def_property_ui_text(prop, "Editable", "Property is editable through RNA.");
687
688         prop= RNA_def_property(srna, "registered", PROP_BOOLEAN, PROP_NONE);
689         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
690         RNA_def_property_boolean_funcs(prop, "rna_Property_registered_get", NULL);
691         RNA_def_property_ui_text(prop, "Registered", "Property is registerd as part of type registration.");
692
693         prop= RNA_def_property(srna, "registered_optional", PROP_BOOLEAN, PROP_NONE);
694         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
695         RNA_def_property_boolean_funcs(prop, "rna_Property_registered_optional_get", NULL);
696         RNA_def_property_ui_text(prop, "Registered Optionally", "Property is optionally registerd as part of type registration.");
697 }
698
699 static void rna_def_function(BlenderRNA *brna)
700 {
701         StructRNA *srna;
702         PropertyRNA *prop;
703
704         srna= RNA_def_struct(brna, "Function", NULL);
705         RNA_def_struct_ui_text(srna, "Function Definition", "RNA function definition");
706         RNA_def_struct_ui_icon(srna, ICON_RNA);
707
708         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
709         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
710         RNA_def_property_string_funcs(prop, "rna_Function_identifier_get", "rna_Function_identifier_length", NULL);
711         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
712         RNA_def_struct_name_property(srna, prop);
713
714         prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
715         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
716         RNA_def_property_string_funcs(prop, "rna_Function_description_get", "rna_Function_description_length", NULL);
717         RNA_def_property_ui_text(prop, "Description", "Description of the Function's purpose.");
718
719         prop= RNA_def_property(srna, "parameters", PROP_COLLECTION, PROP_NONE);
720         /*RNA_def_property_clear_flag(prop, PROP_EDITABLE);*/
721         RNA_def_property_struct_type(prop, "Property");
722         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);
723         RNA_def_property_ui_text(prop, "Parameters", "Parameters for the function.");
724
725         prop= RNA_def_property(srna, "registered", PROP_BOOLEAN, PROP_NONE);
726         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
727         RNA_def_property_boolean_funcs(prop, "rna_Function_registered_get", NULL);
728         RNA_def_property_ui_text(prop, "Registered", "Function is registerd as callback as part of type registration.");
729
730         prop= RNA_def_property(srna, "registered_optional", PROP_BOOLEAN, PROP_NONE);
731         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
732         RNA_def_property_boolean_funcs(prop, "rna_Function_registered_optional_get", NULL);
733         RNA_def_property_ui_text(prop, "Registered Optionally", "Function is optionally registerd as callback part of type registration.");
734 }
735
736 static void rna_def_number_property(StructRNA *srna, PropertyType type)
737 {
738         PropertyRNA *prop;
739
740         prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_UNSIGNED);
741         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
742         RNA_def_property_int_funcs(prop, "rna_Property_array_length_get", NULL, NULL);
743         RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited.");
744
745         if(type == PROP_BOOLEAN)
746                 return;
747
748         prop= RNA_def_property(srna, "hard_min", type, PROP_NONE);
749         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
750         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_min_get", NULL, NULL);
751         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_min_get", NULL, NULL);
752         RNA_def_property_ui_text(prop, "Hard Minimum", "Minimum value used by buttons.");
753
754         prop= RNA_def_property(srna, "hard_max", type, PROP_NONE);
755         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
756         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_max_get", NULL, NULL);
757         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_max_get", NULL, NULL);
758         RNA_def_property_ui_text(prop, "Hard Maximum", "Maximum value used by buttons.");
759
760         prop= RNA_def_property(srna, "soft_min", type, PROP_NONE);
761         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
762         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_min_get", NULL, NULL);
763         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_min_get", NULL, NULL);
764         RNA_def_property_ui_text(prop, "Soft Minimum", "Minimum value used by buttons.");
765
766         prop= RNA_def_property(srna, "soft_max", type, PROP_NONE);
767         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
768         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_max_get", NULL, NULL);
769         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_max_get", NULL, NULL);
770         RNA_def_property_ui_text(prop, "Soft Maximum", "Maximum value used by buttons.");
771
772         prop= RNA_def_property(srna, "step", type, PROP_UNSIGNED);
773         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
774         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_step_get", NULL, NULL);
775         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_step_get", NULL, NULL);
776         RNA_def_property_ui_text(prop, "Step", "Step size used by number buttons, for floats 1/100th of the step size.");
777
778         if(type == PROP_FLOAT) {
779                 prop= RNA_def_property(srna, "precision", PROP_INT, PROP_UNSIGNED);
780                 RNA_def_property_clear_flag(prop, PROP_EDITABLE);
781                 RNA_def_property_int_funcs(prop, "rna_FloatProperty_precision_get", NULL, NULL);
782                 RNA_def_property_ui_text(prop, "Precision", "Number of digits after the dot used by buttons.");
783         }
784 }
785
786 static void rna_def_string_property(StructRNA *srna)
787 {
788         PropertyRNA *prop;
789
790         prop= RNA_def_property(srna, "max_length", PROP_INT, PROP_UNSIGNED);
791         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
792         RNA_def_property_int_funcs(prop, "rna_StringProperty_max_length_get", NULL, NULL);
793         RNA_def_property_ui_text(prop, "Maximum Length", "Maximum length of the string, 0 means unlimited.");
794 }
795
796 static void rna_def_enum_property(BlenderRNA *brna, StructRNA *srna)
797 {
798         PropertyRNA *prop;
799
800         prop= RNA_def_property(srna, "items", PROP_COLLECTION, PROP_NONE);
801         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
802         RNA_def_property_struct_type(prop, "EnumPropertyItem");
803         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);
804         RNA_def_property_ui_text(prop, "Items", "Possible values for the property.");
805
806         srna= RNA_def_struct(brna, "EnumPropertyItem", NULL);
807         RNA_def_struct_ui_text(srna, "Enum Item Definition", "Definition of a choice in an RNA enum property.");
808         RNA_def_struct_ui_icon(srna, ICON_RNA);
809
810         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
811         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
812         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_name_get", "rna_EnumPropertyItem_name_length", NULL);
813         RNA_def_property_ui_text(prop, "Name", "Human readable name.");
814
815         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
816         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
817         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_identifier_get", "rna_EnumPropertyItem_identifier_length", NULL);
818         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
819         RNA_def_struct_name_property(srna, prop);
820
821         prop= RNA_def_property(srna, "value", PROP_INT, PROP_UNSIGNED);
822         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
823         RNA_def_property_int_funcs(prop, "rna_EnumPropertyItem_value_get", NULL, NULL);
824         RNA_def_property_ui_text(prop, "Value", "Value of the item.");
825 }
826
827 static void rna_def_pointer_property(StructRNA *srna, PropertyType type)
828 {
829         PropertyRNA *prop;
830
831         prop= RNA_def_property(srna, "fixed_type", PROP_POINTER, PROP_NONE);
832         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
833         RNA_def_property_struct_type(prop, "Struct");
834         if(type == PROP_POINTER)
835                 RNA_def_property_pointer_funcs(prop, "rna_PointerProperty_fixed_type_get", NULL, NULL);
836         else
837                 RNA_def_property_pointer_funcs(prop, "rna_CollectionProperty_fixed_type_get", NULL, NULL);
838         RNA_def_property_ui_text(prop, "Pointer Type", "Fixed pointer type, empty if variable type.");
839 }
840
841 void RNA_def_rna(BlenderRNA *brna)
842 {
843         StructRNA *srna;
844         PropertyRNA *prop;
845
846         /* Struct*/
847         rna_def_struct(brna);
848
849         /* Property */
850         rna_def_property(brna);
851
852         /* BooleanProperty */
853         srna= RNA_def_struct(brna, "BooleanProperty", "Property");
854         RNA_def_struct_ui_text(srna, "Boolean Definition", "RNA boolean property definition.");
855         rna_def_number_property(srna, PROP_BOOLEAN);
856
857         /* IntProperty */
858         srna= RNA_def_struct(brna, "IntProperty", "Property");
859         RNA_def_struct_ui_text(srna, "Int Definition", "RNA integer number property definition.");
860         rna_def_number_property(srna, PROP_INT);
861
862         /* FloatProperty */
863         srna= RNA_def_struct(brna, "FloatProperty", "Property");
864         RNA_def_struct_ui_text(srna, "Float Definition", "RNA floating pointer number property definition.");
865         rna_def_number_property(srna, PROP_FLOAT);
866
867         /* StringProperty */
868         srna= RNA_def_struct(brna, "StringProperty", "Property");
869         RNA_def_struct_ui_text(srna, "String Definition", "RNA text string property definition.");
870         rna_def_string_property(srna);
871
872         /* EnumProperty */
873         srna= RNA_def_struct(brna, "EnumProperty", "Property");
874         RNA_def_struct_ui_text(srna, "Enum Definition", "RNA enumeration property definition, to choose from a number of predefined options.");
875         rna_def_enum_property(brna, srna);
876
877         /* PointerProperty */
878         srna= RNA_def_struct(brna, "PointerProperty", "Property");
879         RNA_def_struct_ui_text(srna, "Pointer Definition", "RNA pointer property to point to another RNA struct.");
880         rna_def_pointer_property(srna, PROP_POINTER);
881
882         /* CollectionProperty */
883         srna= RNA_def_struct(brna, "CollectionProperty", "Property");
884         RNA_def_struct_ui_text(srna, "Collection Definition", "RNA collection property to define lists, arrays and mappings.");
885         rna_def_pointer_property(srna, PROP_COLLECTION);
886         
887         /* Function */
888         rna_def_function(brna);
889
890         /* Blender RNA */
891         srna= RNA_def_struct(brna, "BlenderRNA", NULL);
892         RNA_def_struct_ui_text(srna, "Blender RNA", "Blender RNA structure definitions.");
893         RNA_def_struct_ui_icon(srna, ICON_RNA);
894
895         prop= RNA_def_property(srna, "structs", PROP_COLLECTION, PROP_NONE);
896         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
897         RNA_def_property_struct_type(prop, "Struct");
898         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);
899         RNA_def_property_ui_text(prop, "Structs", "");
900 }
901
902 #endif
903