RNA
[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 #ifdef RNA_RUNTIME
34
35 /* Struct */
36
37 static void rna_Struct_identifier_get(PointerRNA *ptr, char *value)
38 {
39         strcpy(value, ((StructRNA*)ptr->data)->identifier);
40 }
41
42 static int rna_Struct_identifier_length(PointerRNA *ptr)
43 {
44         return strlen(((StructRNA*)ptr->data)->identifier);
45 }
46
47 static void rna_Struct_description_get(PointerRNA *ptr, char *value)
48 {
49         strcpy(value, ((StructRNA*)ptr->data)->description);
50 }
51
52 static int rna_Struct_description_length(PointerRNA *ptr)
53 {
54         return strlen(((StructRNA*)ptr->data)->description);
55 }
56
57 static void rna_Struct_name_get(PointerRNA *ptr, char *value)
58 {
59         strcpy(value, ((StructRNA*)ptr->data)->name);
60 }
61
62 static int rna_Struct_name_length(PointerRNA *ptr)
63 {
64         return strlen(((StructRNA*)ptr->data)->name);
65 }
66
67 static void *rna_Struct_base_get(PointerRNA *ptr)
68 {
69         return ((StructRNA*)ptr->data)->base;
70 }
71
72 static void *rna_Struct_nested_get(PointerRNA *ptr)
73 {
74         return ((StructRNA*)ptr->data)->nested;
75 }
76
77 static void *rna_Struct_name_property_get(PointerRNA *ptr)
78 {
79         return ((StructRNA*)ptr->data)->nameproperty;
80 }
81
82 static int rna_idproperty_known(CollectionPropertyIterator *iter, void *data)
83 {
84         IDProperty *idprop= (IDProperty*)data;
85         PropertyRNA *prop;
86
87         for(prop= iter->parent.type->properties.first; prop; prop=prop->next)
88                 if(strcmp(prop->identifier, idprop->name) == 0)
89                         return 1;
90         
91         return 0;
92 }
93
94 static int rna_property_builtin(CollectionPropertyIterator *iter, void *data)
95 {
96         PropertyRNA *prop= (PropertyRNA*)data;
97         return (prop->flag & PROP_BUILTIN);
98 }
99
100 static void rna_Struct_properties_next(CollectionPropertyIterator *iter)
101 {
102         ListBaseIterator *internal= iter->internal;
103         IDProperty *group;
104
105         if(internal->flag) {
106                 /* id properties */
107                 rna_iterator_listbase_next(iter);
108         }
109         else {
110                 /* regular properties */
111                 rna_iterator_listbase_next(iter);
112
113                 /* try id properties */
114                 if(!iter->valid) {
115                         group= rna_idproperties_get(&iter->parent, 0);
116
117                         if(group) {
118                                 rna_iterator_listbase_end(iter);
119                                 rna_iterator_listbase_begin(iter, &group->data.group, rna_idproperty_known);
120                                 internal= iter->internal;
121                                 internal->flag= 1;
122                         }
123                 }
124         }
125 }
126
127 static void rna_Struct_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
128 {
129         rna_iterator_listbase_begin(iter, &((StructRNA*)ptr->data)->properties, rna_property_builtin);
130 }
131
132 static void *rna_Struct_properties_get(CollectionPropertyIterator *iter)
133 {
134         ListBaseIterator *internal= iter->internal;
135
136         /* we return either PropertyRNA* or IDProperty*, the rna_access.c
137          * functions can handle both as PropertyRNA* with some tricks */
138         return internal->link;
139 }
140
141 void rna_builtin_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
142 {
143         PointerRNA newptr;
144
145         /* we create a new with the type as the data */
146         newptr.type= &RNA_Struct;
147         newptr.data= ptr->type;
148
149         if(ptr->type->flag & STRUCT_ID) {
150                 newptr.id.type= ptr->type;
151                 newptr.id.data= ptr->data;
152         }
153         else {
154                 newptr.id.type= NULL;
155                 newptr.id.data= NULL;
156         }
157
158         rna_Struct_properties_begin(iter, &newptr);
159 }
160
161 void rna_builtin_properties_next(CollectionPropertyIterator *iter)
162 {
163         rna_Struct_properties_next(iter);
164 }
165
166 void *rna_builtin_properties_get(CollectionPropertyIterator *iter)
167 {
168         return rna_Struct_properties_get(iter);
169 }
170
171 void *rna_builtin_type_get(PointerRNA *ptr)
172 {
173         return ptr->type;
174 }
175
176 /* Property */
177
178 static StructRNA *rna_Property_refine(PointerRNA *ptr)
179 {
180         PropertyRNA *prop= (PropertyRNA*)ptr->data;
181
182         rna_idproperty_check(&prop, ptr); /* XXX ptr? */
183
184         switch(prop->type) {
185                 case PROP_BOOLEAN: return &RNA_BooleanProperty;
186                 case PROP_INT: return &RNA_IntProperty;
187                 case PROP_FLOAT: return &RNA_FloatProperty;
188                 case PROP_STRING: return &RNA_StringProperty;
189                 case PROP_ENUM: return &RNA_EnumProperty;
190                 case PROP_POINTER: return &RNA_PointerProperty;
191                 case PROP_COLLECTION: return &RNA_CollectionProperty;
192                 default: return &RNA_Property;
193         }
194 }
195
196 static void rna_Property_identifier_get(PointerRNA *ptr, char *value)
197 {
198         PropertyRNA *prop= (PropertyRNA*)ptr->data;
199         rna_idproperty_check(&prop, ptr);
200         strcpy(value, ((PropertyRNA*)prop)->identifier);
201 }
202
203 static int rna_Property_identifier_length(PointerRNA *ptr)
204 {
205         PropertyRNA *prop= (PropertyRNA*)ptr->data;
206         rna_idproperty_check(&prop, ptr);
207         return strlen(prop->identifier);
208 }
209
210 static void rna_Property_name_get(PointerRNA *ptr, char *value)
211 {
212         PropertyRNA *prop= (PropertyRNA*)ptr->data;
213         rna_idproperty_check(&prop, ptr);
214         strcpy(value, prop->name);
215 }
216
217 static int rna_Property_name_length(PointerRNA *ptr)
218 {
219         PropertyRNA *prop= (PropertyRNA*)ptr->data;
220         rna_idproperty_check(&prop, ptr);
221         return strlen(prop->name);
222 }
223
224 static void rna_Property_description_get(PointerRNA *ptr, char *value)
225 {
226         PropertyRNA *prop= (PropertyRNA*)ptr->data;
227         rna_idproperty_check(&prop, ptr);
228         strcpy(value, prop->description);
229 }
230
231 static int rna_Property_description_length(PointerRNA *ptr)
232 {
233         PropertyRNA *prop= (PropertyRNA*)ptr->data;
234         rna_idproperty_check(&prop, ptr);
235         return strlen(prop->description);
236 }
237
238 static int rna_Property_type_get(PointerRNA *ptr)
239 {
240         PropertyRNA *prop= (PropertyRNA*)ptr->data;
241         rna_idproperty_check(&prop, ptr);
242         return prop->type;
243 }
244
245 static int rna_Property_subtype_get(PointerRNA *ptr)
246 {
247         PropertyRNA *prop= (PropertyRNA*)ptr->data;
248         rna_idproperty_check(&prop, ptr);
249         return prop->subtype;
250 }
251
252 static int rna_Property_editable_get(PointerRNA *ptr)
253 {
254         PropertyRNA *prop= (PropertyRNA*)ptr->data;
255         return RNA_property_editable(ptr, prop);
256 }
257
258 static int rna_Property_array_length_get(PointerRNA *ptr)
259 {
260         PropertyRNA *prop= (PropertyRNA*)ptr->data;
261         rna_idproperty_check(&prop, ptr);
262         return prop->arraylength;
263 }
264
265 static int rna_IntProperty_hard_min_get(PointerRNA *ptr)
266 {
267         PropertyRNA *prop= (PropertyRNA*)ptr->data;
268         rna_idproperty_check(&prop, ptr);
269         return ((IntPropertyRNA*)prop)->hardmin;
270 }
271
272 static int rna_IntProperty_hard_max_get(PointerRNA *ptr)
273 {
274         PropertyRNA *prop= (PropertyRNA*)ptr->data;
275         rna_idproperty_check(&prop, ptr);
276         return ((IntPropertyRNA*)prop)->hardmax;
277 }
278
279 static int rna_IntProperty_soft_min_get(PointerRNA *ptr)
280 {
281         PropertyRNA *prop= (PropertyRNA*)ptr->data;
282         rna_idproperty_check(&prop, ptr);
283         return ((IntPropertyRNA*)prop)->softmin;
284 }
285
286 static int rna_IntProperty_soft_max_get(PointerRNA *ptr)
287 {
288         PropertyRNA *prop= (PropertyRNA*)ptr->data;
289         rna_idproperty_check(&prop, ptr);
290         return ((IntPropertyRNA*)prop)->softmax;
291 }
292
293 static int rna_IntProperty_step_get(PointerRNA *ptr)
294 {
295         PropertyRNA *prop= (PropertyRNA*)ptr->data;
296         rna_idproperty_check(&prop, ptr);
297         return ((IntPropertyRNA*)prop)->step;
298 }
299
300 static float rna_FloatProperty_hard_min_get(PointerRNA *ptr)
301 {
302         PropertyRNA *prop= (PropertyRNA*)ptr->data;
303         rna_idproperty_check(&prop, ptr);
304         return ((FloatPropertyRNA*)prop)->hardmin;
305 }
306
307 static float rna_FloatProperty_hard_max_get(PointerRNA *ptr)
308 {
309         PropertyRNA *prop= (PropertyRNA*)ptr->data;
310         rna_idproperty_check(&prop, ptr);
311         return ((FloatPropertyRNA*)prop)->hardmax;
312 }
313
314 static float rna_FloatProperty_soft_min_get(PointerRNA *ptr)
315 {
316         PropertyRNA *prop= (PropertyRNA*)ptr->data;
317         rna_idproperty_check(&prop, ptr);
318         return ((FloatPropertyRNA*)prop)->softmin;
319 }
320
321 static float rna_FloatProperty_soft_max_get(PointerRNA *ptr)
322 {
323         PropertyRNA *prop= (PropertyRNA*)ptr->data;
324         rna_idproperty_check(&prop, ptr);
325         return ((FloatPropertyRNA*)prop)->softmax;
326 }
327
328 static float rna_FloatProperty_step_get(PointerRNA *ptr)
329 {
330         PropertyRNA *prop= (PropertyRNA*)ptr->data;
331         rna_idproperty_check(&prop, ptr);
332         return ((FloatPropertyRNA*)prop)->step;
333 }
334
335 static int rna_FloatProperty_precision_get(PointerRNA *ptr)
336 {
337         PropertyRNA *prop= (PropertyRNA*)ptr->data;
338         rna_idproperty_check(&prop, ptr);
339         return ((FloatPropertyRNA*)prop)->precision;
340 }
341
342 static int rna_StringProperty_max_length_get(PointerRNA *ptr)
343 {
344         PropertyRNA *prop= (PropertyRNA*)ptr->data;
345         rna_idproperty_check(&prop, ptr);
346         return ((StringPropertyRNA*)prop)->maxlength;
347 }
348
349 static void rna_EnumProperty_items_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
350 {
351         PropertyRNA *prop= (PropertyRNA*)ptr->data;
352         EnumPropertyRNA *eprop;
353
354         rna_idproperty_check(&prop, ptr);
355         eprop= (EnumPropertyRNA*)prop;
356
357         rna_iterator_array_begin(iter, (void*)eprop->item, sizeof(eprop->item[0]), eprop->totitem, NULL);
358 }
359
360 static void rna_EnumPropertyItem_identifier_get(PointerRNA *ptr, char *value)
361 {
362         strcpy(value, ((EnumPropertyItem*)ptr->data)->identifier);
363 }
364
365 static int rna_EnumPropertyItem_identifier_length(PointerRNA *ptr)
366 {
367         return strlen(((EnumPropertyItem*)ptr->data)->identifier);
368 }
369
370 static void rna_EnumPropertyItem_name_get(PointerRNA *ptr, char *value)
371 {
372         strcpy(value, ((EnumPropertyItem*)ptr->data)->name);
373 }
374
375 static int rna_EnumPropertyItem_name_length(PointerRNA *ptr)
376 {
377         return strlen(((EnumPropertyItem*)ptr->data)->name);
378 }
379
380 static int rna_EnumPropertyItem_value_get(PointerRNA *ptr)
381 {
382         return ((EnumPropertyItem*)ptr->data)->value;
383 }
384
385 static void *rna_PointerProperty_fixed_type_get(PointerRNA *ptr)
386 {
387         PropertyRNA *prop= (PropertyRNA*)ptr->data;
388         rna_idproperty_check(&prop, ptr);
389         return ((PointerPropertyRNA*)prop)->structtype;
390 }
391
392 static void *rna_CollectionProperty_fixed_type_get(PointerRNA *ptr)
393 {
394         PropertyRNA *prop= (PropertyRNA*)ptr->data;
395         rna_idproperty_check(&prop, ptr);
396         return ((CollectionPropertyRNA*)prop)->structtype;
397 }
398
399 /* Blender RNA */
400
401 static void rna_BlenderRNA_structs_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
402 {
403         rna_iterator_listbase_begin(iter, &((BlenderRNA*)ptr->data)->structs, NULL);
404 }
405
406 #else
407
408 static void rna_def_struct(BlenderRNA *brna)
409 {
410         StructRNA *srna;
411         PropertyRNA *prop;
412
413         srna= RNA_def_struct(brna, "Struct", NULL);
414         RNA_def_struct_ui_text(srna, "Struct Definition", "RNA structure definition");
415
416         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
417         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
418         RNA_def_property_string_funcs(prop, "rna_Struct_name_get", "rna_Struct_name_length", NULL);
419         RNA_def_property_ui_text(prop, "Name", "Human readable name.");
420
421         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
422         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
423         RNA_def_property_string_funcs(prop, "rna_Struct_identifier_get", "rna_Struct_identifier_length", NULL);
424         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
425         RNA_def_struct_name_property(srna, prop);
426         
427         prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
428         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
429         RNA_def_property_string_funcs(prop, "rna_Struct_description_get", "rna_Struct_description_length", NULL);
430         RNA_def_property_ui_text(prop, "Description", "Description of the Struct's purpose.");
431         
432         prop= RNA_def_property(srna, "base", PROP_POINTER, PROP_NONE);
433         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
434         RNA_def_property_struct_type(prop, "Struct");
435         RNA_def_property_pointer_funcs(prop, "rna_Struct_base_get", NULL, NULL);
436         RNA_def_property_ui_text(prop, "Base", "Struct definition this is derived from.");
437
438         prop= RNA_def_property(srna, "nested", PROP_POINTER, PROP_NONE);
439         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
440         RNA_def_property_struct_type(prop, "Struct");
441         RNA_def_property_pointer_funcs(prop, "rna_Struct_nested_get", NULL, NULL);
442         RNA_def_property_ui_text(prop, "Nested", "Struct in which this struct is always nested, and to which it logically belongs.");
443
444         prop= RNA_def_property(srna, "name_property", PROP_POINTER, PROP_NONE);
445         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
446         RNA_def_property_struct_type(prop, "StringProperty");
447         RNA_def_property_pointer_funcs(prop, "rna_Struct_name_property_get", NULL, NULL);
448         RNA_def_property_ui_text(prop, "Name Property", "Property that gives the name of the struct.");
449
450         prop= RNA_def_property(srna, "properties", PROP_COLLECTION, PROP_NONE);
451         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
452         RNA_def_property_struct_type(prop, "Property");
453         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);
454         RNA_def_property_ui_text(prop, "Properties", "Properties in the struct.");
455 }
456
457 static void rna_def_property(BlenderRNA *brna)
458 {
459         StructRNA *srna;
460         PropertyRNA *prop;
461         static EnumPropertyItem type_items[] = {
462                 {PROP_BOOLEAN, "BOOLEAN", "Boolean", ""},
463                 {PROP_INT, "INT", "Integer", ""},
464                 {PROP_FLOAT, "FLOAT", "Float", ""},
465                 {PROP_STRING, "STRING", "String", ""},
466                 {PROP_ENUM, "ENUM", "Enumeration", ""},
467                 {PROP_POINTER, "POINTER", "Pointer", ""},
468                 {PROP_COLLECTION, "COLLECTION", "Collection", ""},
469                 {0, NULL, NULL, NULL}};
470         static EnumPropertyItem subtype_items[] = {
471                 {PROP_NONE, "NONE", "None", ""},
472                 {PROP_UNSIGNED, "UNSIGNED", "Unsigned Number", ""},
473                 {PROP_FILEPATH, "FILE_PATH", "File Path", ""},
474                 {PROP_DIRPATH, "DIRECTORY_PATH", "Directory Path", ""},
475                 {PROP_COLOR, "COLOR", "Color", ""},
476                 {PROP_VECTOR, "VECTOR", "Vector", ""},
477                 {PROP_MATRIX, "MATRIX", "Matrix", ""},
478                 {PROP_ROTATION, "ROTATION", "Rotation", ""},
479                 {PROP_NEVER_NULL, "NEVER_NULL", "Never Null", ""},
480                 {0, NULL, NULL, NULL}};
481
482         srna= RNA_def_struct(brna, "Property", NULL);
483         RNA_def_struct_ui_text(srna, "Property Definition", "RNA property definition.");
484         RNA_def_struct_refine_func(srna, "rna_Property_refine");
485
486         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
487         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
488         RNA_def_property_string_funcs(prop, "rna_Property_name_get", "rna_Property_name_length", NULL);
489         RNA_def_property_ui_text(prop, "Name", "Human readable name.");
490
491         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
492         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
493         RNA_def_property_string_funcs(prop, "rna_Property_identifier_get", "rna_Property_identifier_length", NULL);
494         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
495         RNA_def_struct_name_property(srna, prop);
496                 
497         prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
498         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
499         RNA_def_property_string_funcs(prop, "rna_Property_description_get", "rna_Property_description_length", NULL);
500         RNA_def_property_ui_text(prop, "Description", "Description of the property for tooltips.");
501
502         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
503         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
504         RNA_def_property_enum_items(prop, type_items);
505         RNA_def_property_enum_funcs(prop, "rna_Property_type_get", NULL);
506         RNA_def_property_ui_text(prop, "Type", "Data type of the property.");
507
508         prop= RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
509         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
510         RNA_def_property_enum_items(prop, subtype_items);
511         RNA_def_property_enum_funcs(prop, "rna_Property_subtype_get", NULL);
512         RNA_def_property_ui_text(prop, "Subtype", "Semantic interpretation of the property.");
513
514         prop= RNA_def_property(srna, "editable", PROP_BOOLEAN, PROP_NONE);
515         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
516         RNA_def_property_boolean_funcs(prop, "rna_Property_editable_get", NULL);
517         RNA_def_property_ui_text(prop, "Editable", "Property is editable through RNA.");
518 }
519
520 static void rna_def_number_property(StructRNA *srna, PropertyType type)
521 {
522         PropertyRNA *prop;
523
524         prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_UNSIGNED);
525         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
526         RNA_def_property_int_funcs(prop, "rna_Property_array_length_get", NULL, NULL);
527         RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited.");
528
529         if(type == PROP_BOOLEAN)
530                 return;
531
532         prop= RNA_def_property(srna, "hard_min", type, PROP_NONE);
533         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
534         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_min_get", NULL, NULL);
535         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_min_get", NULL, NULL);
536         RNA_def_property_ui_text(prop, "Hard Minimum", "Minimum value used by buttons.");
537
538         prop= RNA_def_property(srna, "hard_max", type, PROP_NONE);
539         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
540         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_max_get", NULL, NULL);
541         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_max_get", NULL, NULL);
542         RNA_def_property_ui_text(prop, "Hard Maximum", "Maximum value used by buttons.");
543
544         prop= RNA_def_property(srna, "soft_min", type, PROP_NONE);
545         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
546         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_min_get", NULL, NULL);
547         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_min_get", NULL, NULL);
548         RNA_def_property_ui_text(prop, "Soft Minimum", "Minimum value used by buttons.");
549
550         prop= RNA_def_property(srna, "soft_max", type, PROP_NONE);
551         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
552         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_max_get", NULL, NULL);
553         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_max_get", NULL, NULL);
554         RNA_def_property_ui_text(prop, "Soft Maximum", "Maximum value used by buttons.");
555
556         prop= RNA_def_property(srna, "step", type, PROP_UNSIGNED);
557         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
558         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_step_get", NULL, NULL);
559         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_step_get", NULL, NULL);
560         RNA_def_property_ui_text(prop, "Step", "Step size used by number buttons, for floats 1/100th of the step size.");
561
562         if(type == PROP_FLOAT) {
563                 prop= RNA_def_property(srna, "precision", PROP_INT, PROP_UNSIGNED);
564                 RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
565                 RNA_def_property_int_funcs(prop, "rna_FloatProperty_precision_get", NULL, NULL);
566                 RNA_def_property_ui_text(prop, "Precision", "Number of digits after the dot used by buttons.");
567         }
568 }
569
570 static void rna_def_string_property(StructRNA *srna)
571 {
572         PropertyRNA *prop;
573
574         prop= RNA_def_property(srna, "max_length", PROP_INT, PROP_UNSIGNED);
575         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
576         RNA_def_property_int_funcs(prop, "rna_StringProperty_max_length_get", NULL, NULL);
577         RNA_def_property_ui_text(prop, "Maximum Length", "Maximum length of the string, 0 means unlimited.");
578 }
579
580 static void rna_def_enum_property(BlenderRNA *brna, StructRNA *srna)
581 {
582         PropertyRNA *prop;
583
584         prop= RNA_def_property(srna, "items", PROP_COLLECTION, PROP_NONE);
585         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
586         RNA_def_property_struct_type(prop, "EnumPropertyItem");
587         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);
588         RNA_def_property_ui_text(prop, "Items", "Possible values for the property.");
589
590         srna= RNA_def_struct(brna, "EnumPropertyItem", NULL);
591         RNA_def_struct_ui_text(srna, "Enum Item Definition", "Definition of a choice in an RNA enum property.");
592
593         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
594         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
595         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_name_get", "rna_EnumPropertyItem_name_length", NULL);
596         RNA_def_property_ui_text(prop, "Name", "Human readable name.");
597
598         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
599         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
600         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_identifier_get", "rna_EnumPropertyItem_identifier_length", NULL);
601         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
602         RNA_def_struct_name_property(srna, prop);
603
604         prop= RNA_def_property(srna, "value", PROP_INT, PROP_UNSIGNED);
605         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
606         RNA_def_property_int_funcs(prop, "rna_EnumPropertyItem_value_get", NULL, NULL);
607         RNA_def_property_ui_text(prop, "Value", "Value of the item.");
608 }
609
610 static void rna_def_pointer_property(StructRNA *srna, PropertyType type)
611 {
612         PropertyRNA *prop;
613
614         prop= RNA_def_property(srna, "fixed_type", PROP_POINTER, PROP_NONE);
615         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
616         RNA_def_property_struct_type(prop, "Struct");
617         if(type == PROP_POINTER)
618                 RNA_def_property_pointer_funcs(prop, "rna_PointerProperty_fixed_type_get", NULL, NULL);
619         else
620                 RNA_def_property_pointer_funcs(prop, "rna_CollectionProperty_fixed_type_get", NULL, NULL);
621         RNA_def_property_ui_text(prop, "Pointer Type", "Fixed pointer type, empty if variable type.");
622 }
623
624 void RNA_def_rna(BlenderRNA *brna)
625 {
626         StructRNA *srna;
627         PropertyRNA *prop;
628
629         /* Struct*/
630         rna_def_struct(brna);
631
632         /* Property */
633         rna_def_property(brna);
634
635         /* BooleanProperty */
636         srna= RNA_def_struct(brna, "BooleanProperty", "Property");
637         RNA_def_struct_ui_text(srna, "Boolean Definition", "RNA boolean property definition.");
638         rna_def_number_property(srna, PROP_BOOLEAN);
639
640         /* IntProperty */
641         srna= RNA_def_struct(brna, "IntProperty", "Property");
642         RNA_def_struct_ui_text(srna, "Int Definition", "RNA integer number property definition.");
643         rna_def_number_property(srna, PROP_INT);
644
645         /* FloatProperty */
646         srna= RNA_def_struct(brna, "FloatProperty", "Property");
647         RNA_def_struct_ui_text(srna, "Float Definition", "RNA floating pointer number property definition.");
648         rna_def_number_property(srna, PROP_FLOAT);
649
650         /* StringProperty */
651         srna= RNA_def_struct(brna, "StringProperty", "Property");
652         RNA_def_struct_ui_text(srna, "String Definition", "RNA text string property definition.");
653         rna_def_string_property(srna);
654
655         /* EnumProperty */
656         srna= RNA_def_struct(brna, "EnumProperty", "Property");
657         RNA_def_struct_ui_text(srna, "Enum Definition", "RNA enumeration property definition, to choose from a number of predefined options.");
658         rna_def_enum_property(brna, srna);
659
660         /* PointerProperty */
661         srna= RNA_def_struct(brna, "PointerProperty", "Property");
662         RNA_def_struct_ui_text(srna, "Pointer Definition", "RNA pointer property to point to another RNA struct.");
663         rna_def_pointer_property(srna, PROP_POINTER);
664
665         /* CollectionProperty */
666         srna= RNA_def_struct(brna, "CollectionProperty", "Property");
667         RNA_def_struct_ui_text(srna, "Collection Definition", "RNA collection property to define lists, arrays and mappings.");
668         rna_def_pointer_property(srna, PROP_COLLECTION);
669
670         /* Blender RNA */
671         srna= RNA_def_struct(brna, "BlenderRNA", NULL);
672         RNA_def_struct_ui_text(srna, "Blender RNA", "Blender RNA structure definitions.");
673
674         prop= RNA_def_property(srna, "structs", PROP_COLLECTION, PROP_NONE);
675         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
676         RNA_def_property_struct_type(prop, "Struct");
677         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);
678         RNA_def_property_ui_text(prop, "Structs", "");
679 }
680
681 #endif
682