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