60faf0c8e07f35b86cbdae18ed4e3d036ffe9cc5
[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)->from;
70 }
71
72 static void *rna_Struct_parent_get(PointerRNA *ptr)
73 {
74         return ((StructRNA*)ptr->data)->parent;
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, "parent", 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_parent_get", NULL, NULL);
442         RNA_def_property_ui_text(prop, "Parent", "Parent struct, used only for nested structs.");
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, "FILEPATH", "File Path", ""},
474                 {PROP_DIRPATH, "DIRPATH", "Directory Path", ""},
475                 {PROP_COLOR, "COLOR", "Color", ""},
476                 {PROP_VECTOR, "VECTOR", "Vector", ""},
477                 {PROP_MATRIX, "MATRIX", "Matrix", ""},
478                 {PROP_ROTATION, "ROTATION", "Rotation", ""},
479                 {0, NULL, NULL, NULL}};
480
481         srna= RNA_def_struct(brna, "Property", NULL);
482         RNA_def_struct_ui_text(srna, "Property Definition", "DOC_BROKEN2");
483         RNA_def_struct_refine_func(srna, "rna_Property_refine");
484
485         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
486         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
487         RNA_def_property_string_funcs(prop, "rna_Property_name_get", "rna_Property_name_length", NULL);
488         RNA_def_property_ui_text(prop, "Name", "Human readable name.");
489
490         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
491         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
492         RNA_def_property_string_funcs(prop, "rna_Property_identifier_get", "rna_Property_identifier_length", NULL);
493         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
494         RNA_def_struct_name_property(srna, prop);
495                 
496         prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
497         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
498         RNA_def_property_string_funcs(prop, "rna_Property_description_get", "rna_Property_description_length", NULL);
499         RNA_def_property_ui_text(prop, "Description", "Description of the property for tooltips.");
500
501         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
502         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
503         RNA_def_property_enum_items(prop, type_items);
504         RNA_def_property_enum_funcs(prop, "rna_Property_type_get", NULL);
505         RNA_def_property_ui_text(prop, "Type", "Data type of the property.");
506
507         prop= RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
508         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
509         RNA_def_property_enum_items(prop, subtype_items);
510         RNA_def_property_enum_funcs(prop, "rna_Property_subtype_get", NULL);
511         RNA_def_property_ui_text(prop, "Subtype", "Semantic interpretation of the property.");
512         
513         prop= RNA_def_property(srna, "editable", PROP_BOOLEAN, PROP_NONE);
514         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
515         RNA_def_property_boolean_funcs(prop, "rna_Property_editable_get", NULL);
516         RNA_def_property_ui_text(prop, "Editable", "Property is editable through RNA.");
517 }
518
519 static void rna_def_number_property(StructRNA *srna, PropertyType type)
520 {
521         PropertyRNA *prop;
522
523         prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_UNSIGNED);
524         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
525         RNA_def_property_int_funcs(prop, "rna_Property_array_length_get", NULL, NULL);
526         RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited.");
527
528         if(type == PROP_BOOLEAN)
529                 return;
530
531         prop= RNA_def_property(srna, "hard_min", type, PROP_NONE);
532         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
533         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_min_get", NULL, NULL);
534         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_min_get", NULL, NULL);
535         RNA_def_property_ui_text(prop, "Hard Minimum", "Minimum value used by buttons.");
536
537         prop= RNA_def_property(srna, "hard_max", type, PROP_NONE);
538         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
539         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_max_get", NULL, NULL);
540         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_max_get", NULL, NULL);
541         RNA_def_property_ui_text(prop, "Hard Maximum", "Maximum value used by buttons.");
542
543         prop= RNA_def_property(srna, "soft_min", type, PROP_NONE);
544         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
545         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_min_get", NULL, NULL);
546         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_min_get", NULL, NULL);
547         RNA_def_property_ui_text(prop, "Soft Minimum", "Minimum value used by buttons.");
548
549         prop= RNA_def_property(srna, "soft_max", type, PROP_NONE);
550         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
551         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_max_get", NULL, NULL);
552         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_max_get", NULL, NULL);
553         RNA_def_property_ui_text(prop, "Soft Maximum", "Maximum value used by buttons.");
554
555         prop= RNA_def_property(srna, "step", type, PROP_UNSIGNED);
556         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
557         if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_step_get", NULL, NULL);
558         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_step_get", NULL, NULL);
559         RNA_def_property_ui_text(prop, "Step", "Step size used by number buttons, for floats 1/100th of the step size.");
560
561         if(type == PROP_FLOAT) {
562                 prop= RNA_def_property(srna, "precision", PROP_INT, PROP_UNSIGNED);
563                 RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
564                 RNA_def_property_int_funcs(prop, "rna_FloatProperty_precision_get", NULL, NULL);
565                 RNA_def_property_ui_text(prop, "Precision", "Number of digits after the dot used by buttons.");
566         }
567 }
568
569 static void rna_def_string_property(StructRNA *srna)
570 {
571         PropertyRNA *prop;
572
573         prop= RNA_def_property(srna, "max_length", PROP_INT, PROP_UNSIGNED);
574         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
575         RNA_def_property_int_funcs(prop, "rna_StringProperty_max_length_get", NULL, NULL);
576         RNA_def_property_ui_text(prop, "Maximum Length", "Maximum length of the string, 0 means unlimited.");
577 }
578
579 static void rna_def_enum_property(BlenderRNA *brna, StructRNA *srna)
580 {
581         PropertyRNA *prop;
582
583         prop= RNA_def_property(srna, "items", PROP_COLLECTION, PROP_NONE);
584         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
585         RNA_def_property_struct_type(prop, "EnumPropertyItem");
586         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);
587         RNA_def_property_ui_text(prop, "Items", "Possible values for the property.");
588
589         srna= RNA_def_struct(brna, "EnumPropertyItem", NULL);
590         RNA_def_struct_ui_text(srna, "Enum Item Definition", "DOC_BROKEN3");
591
592         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
593         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
594         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_name_get", "rna_EnumPropertyItem_name_length", NULL);
595         RNA_def_property_ui_text(prop, "Name", "Human readable name.");
596
597         prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
598         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
599         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_identifier_get", "rna_EnumPropertyItem_identifier_length", NULL);
600         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
601         RNA_def_struct_name_property(srna, prop);
602
603         prop= RNA_def_property(srna, "value", PROP_INT, PROP_UNSIGNED);
604         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
605         RNA_def_property_int_funcs(prop, "rna_EnumPropertyItem_value_get", NULL, NULL);
606         RNA_def_property_ui_text(prop, "Value", "Value of the item.");
607 }
608
609 static void rna_def_pointer_property(StructRNA *srna, PropertyType type)
610 {
611         PropertyRNA *prop;
612
613         prop= RNA_def_property(srna, "fixed_type", PROP_POINTER, PROP_NONE);
614         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
615         RNA_def_property_struct_type(prop, "Struct");
616         if(type == PROP_POINTER)
617                 RNA_def_property_pointer_funcs(prop, "rna_PointerProperty_fixed_type_get", NULL, NULL);
618         else
619                 RNA_def_property_pointer_funcs(prop, "rna_CollectionProperty_fixed_type_get", NULL, NULL);
620         RNA_def_property_ui_text(prop, "Pointer Type", "Fixed pointer type, empty if variable type.");
621 }
622
623 void RNA_def_rna(BlenderRNA *brna)
624 {
625         StructRNA *srna;
626         PropertyRNA *prop;
627
628         /* Struct*/
629         rna_def_struct(brna);
630
631         /* Property */
632         rna_def_property(brna);
633
634         /* BooleanProperty */
635         srna= RNA_def_struct(brna, "BooleanProperty", "Property");
636         RNA_def_struct_ui_text(srna, "Boolean Definition", "DOC_BROKEN4");
637         rna_def_number_property(srna, PROP_BOOLEAN);
638
639         /* IntProperty */
640         srna= RNA_def_struct(brna, "IntProperty", "Property");
641         RNA_def_struct_ui_text(srna, "Int Definition", "DOC_BROKEN5");
642         rna_def_number_property(srna, PROP_INT);
643
644         /* FloatProperty */
645         srna= RNA_def_struct(brna, "FloatProperty", "Property");
646         RNA_def_struct_ui_text(srna, "Float Definition", "DOC_BROKEN6");
647         rna_def_number_property(srna, PROP_FLOAT);
648
649         /* StringProperty */
650         srna= RNA_def_struct(brna, "StringProperty", "Property");
651         RNA_def_struct_ui_text(srna, "String Definition", "DOC_BROKEN7");
652         rna_def_string_property(srna);
653
654         /* EnumProperty */
655         srna= RNA_def_struct(brna, "EnumProperty", "Property");
656         RNA_def_struct_ui_text(srna, "Enum Definition", "DOC_BROKEN8");
657         rna_def_enum_property(brna, srna);
658
659         /* PointerProperty */
660         srna= RNA_def_struct(brna, "PointerProperty", "Property");
661         RNA_def_struct_ui_text(srna, "Pointer Definition", "DOC_BROKEN9");
662         rna_def_pointer_property(srna, PROP_POINTER);
663
664         /* CollectionProperty */
665         srna= RNA_def_struct(brna, "CollectionProperty", "Property");
666         RNA_def_struct_ui_text(srna, "Collection Definition", "DOC_BROKEN10");
667         rna_def_pointer_property(srna, PROP_COLLECTION);
668
669         /* Blender RNA */
670         srna= RNA_def_struct(brna, "BlenderRNA", NULL);
671         RNA_def_struct_ui_text(srna, "Blender RNA", "RNA Structures");
672
673         prop= RNA_def_property(srna, "structs", PROP_COLLECTION, PROP_NONE);
674         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
675         RNA_def_property_struct_type(prop, "Struct");
676         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);
677         RNA_def_property_ui_text(prop, "Structs", "");
678 }
679
680 #endif
681