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 "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_StructRNA_cname_get(PointerRNA *ptr, char *value)
36 {
37         strcpy(value, ((StructRNA*)ptr->data)->cname);
38 }
39
40 static int rna_StructRNA_cname_length(PointerRNA *ptr)
41 {
42         return strlen(((StructRNA*)ptr->data)->cname);
43 }
44
45 static void rna_StructRNA_name_get(PointerRNA *ptr, char *value)
46 {
47         strcpy(value, ((StructRNA*)ptr->data)->name);
48 }
49
50 static int rna_StructRNA_name_length(PointerRNA *ptr)
51 {
52         return strlen(((StructRNA*)ptr->data)->name);
53 }
54
55 static void *rna_StructRNA_name_property_get(PointerRNA *ptr)
56 {
57         return ((StructRNA*)ptr->data)->nameproperty;
58 }
59
60 static void rna_StructRNA_properties_next(CollectionPropertyIterator *iter)
61 {
62         do {
63                 rna_iterator_listbase_next(iter);
64         } while(iter->valid && (((PropertyRNA*)iter->internal)->flag & PROP_BUILTIN));
65 }
66
67 static void rna_StructRNA_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
68 {
69         rna_iterator_listbase_begin(iter, &((StructRNA*)ptr->data)->properties);
70
71         if(iter->valid && (((PropertyRNA*)iter->internal)->flag & PROP_BUILTIN))
72                 rna_StructRNA_properties_next(iter);
73 }
74
75 static void *rna_StructRNA_properties_get(CollectionPropertyIterator *iter)
76 {
77         return rna_iterator_listbase_get(iter);
78 }
79
80 static StructRNA *rna_StructRNA_properties_type(CollectionPropertyIterator *iter)
81 {
82         PropertyRNA *prop= iter->internal;
83
84         switch(prop->type) {
85                 case PROP_BOOLEAN: return &RNA_BooleanPropertyRNA;
86                 case PROP_INT: return &RNA_IntPropertyRNA;
87                 case PROP_FLOAT: return &RNA_FloatPropertyRNA;
88                 case PROP_STRING: return &RNA_StringPropertyRNA;
89                 case PROP_ENUM: return &RNA_EnumPropertyRNA;
90                 case PROP_POINTER: return &RNA_PointerPropertyRNA;
91                 case PROP_COLLECTION: return &RNA_CollectionPropertyRNA;
92                 default: return NULL;
93         }
94 }
95
96 static void rna_builtin_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
97 {
98         PointerRNA newptr;
99
100         /* we create a new with the type as the data */
101         newptr.type= &RNA_StructRNA;
102         newptr.data= ptr->type;
103
104         if(ptr->type->flag & STRUCT_ID) {
105                 newptr.id.type= ptr->type;
106                 newptr.id.data= ptr->data;
107         }
108         else {
109                 newptr.id.type= NULL;
110                 newptr.id.data= NULL;
111         }
112
113         rna_StructRNA_properties_begin(iter, &newptr);
114 }
115
116 static void rna_builtin_properties_next(CollectionPropertyIterator *iter)
117 {
118         rna_StructRNA_properties_next(iter);
119 }
120
121 static void *rna_builtin_properties_get(CollectionPropertyIterator *iter)
122 {
123         return rna_StructRNA_properties_get(iter);
124 }
125
126 static StructRNA *rna_builtin_properties_type(CollectionPropertyIterator *iter)
127 {
128         return rna_StructRNA_properties_type(iter);
129 }
130
131 static void *rna_builtin_type_get(PointerRNA *ptr)
132 {
133         return ptr->type;
134 }
135
136 /* Property */
137
138 static void rna_PropertyRNA_cname_get(PointerRNA *ptr, char *value)
139 {
140         strcpy(value, ((PropertyRNA*)ptr->data)->cname);
141 }
142
143 static int rna_PropertyRNA_cname_length(PointerRNA *ptr)
144 {
145         return strlen(((PropertyRNA*)ptr->data)->cname);
146 }
147
148 static void rna_PropertyRNA_name_get(PointerRNA *ptr, char *value)
149 {
150         strcpy(value, ((PropertyRNA*)ptr->data)->name);
151 }
152
153 static int rna_PropertyRNA_name_length(PointerRNA *ptr)
154 {
155         return strlen(((PropertyRNA*)ptr->data)->name);
156 }
157
158 static void rna_PropertyRNA_description_get(PointerRNA *ptr, char *value)
159 {
160         strcpy(value, ((PropertyRNA*)ptr->data)->description);
161 }
162
163 static int rna_PropertyRNA_description_length(PointerRNA *ptr)
164 {
165         return strlen(((PropertyRNA*)ptr->data)->description);
166 }
167
168 static int rna_PropertyRNA_type_get(PointerRNA *ptr)
169 {
170         return ((PropertyRNA*)ptr->data)->type;
171 }
172
173 static int rna_PropertyRNA_subtype_get(PointerRNA *ptr)
174 {
175         return ((PropertyRNA*)ptr->data)->subtype;
176 }
177
178 static int rna_PropertyRNA_array_length_get(PointerRNA *ptr)
179 {
180         return ((PropertyRNA*)ptr->data)->arraylength;
181 }
182
183 static int rna_PropertyRNA_max_length_get(PointerRNA *ptr)
184 {
185         return ((StringPropertyRNA*)ptr->data)->maxlength;
186 }
187
188 #else
189
190 static void rna_def_property(StructRNA *srna)
191 {
192         PropertyRNA *prop;
193         static PropertyEnumItem type_items[] = {
194                 {PROP_BOOLEAN, "BOOLEAN", "Boolean"},
195                 {PROP_INT, "INT", "Integer"},
196                 {PROP_FLOAT, "FLOAT", "Float"},
197                 {PROP_STRING, "STRING", "String"},
198                 {PROP_ENUM, "ENUM", "Enumeration"},
199                 {PROP_POINTER, "POINTER", "Pointer"},
200                 {PROP_COLLECTION, "COLLECTION", "Collection"},
201                 {0, NULL, NULL}};
202         static PropertyEnumItem subtype_items[] = {
203                 {PROP_NONE, "NONE", "None"},
204                 {PROP_UNSIGNED, "UNSIGNED", "Unsigned Number"},
205                 {PROP_FILEPATH, "FILEPATH", "File Path"},
206                 {PROP_COLOR, "COLOR", "Color"},
207                 {PROP_VECTOR, "VECTOR", "Vector"},
208                 {PROP_MATRIX, "MATRIX", "Matrix"},
209                 {PROP_ROTATION, "ROTATION", "Rotation"},
210                 {0, NULL, NULL}};
211
212         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
213         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
214         RNA_def_property_string_funcs(prop, "rna_PropertyRNA_name_get", "rna_PropertyRNA_name_length", NULL);
215         RNA_def_property_ui_text(prop, "Name", "Human readable name.");
216         RNA_def_struct_name_property(srna, prop);
217
218         prop= RNA_def_property(srna, "cname", PROP_STRING, PROP_NONE);
219         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
220         RNA_def_property_string_funcs(prop, "rna_PropertyRNA_cname_get", "rna_PropertyRNA_cname_length", NULL);
221         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
222
223         prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
224         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
225         RNA_def_property_string_funcs(prop, "rna_PropertyRNA_description_get", "rna_PropertyRNA_description_length", NULL);
226         RNA_def_property_ui_text(prop, "Description", "Description of the property for tooltips.");
227
228         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
229         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
230         RNA_def_property_enum_items(prop, type_items);
231         RNA_def_property_enum_funcs(prop, "rna_PropertyRNA_type_get", NULL);
232         RNA_def_property_ui_text(prop, "Type", "Data type of the property.");
233
234         prop= RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
235         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
236         RNA_def_property_enum_items(prop, subtype_items);
237         RNA_def_property_enum_funcs(prop, "rna_PropertyRNA_subtype_get", NULL);
238         RNA_def_property_ui_text(prop, "Sub Type", "Sub type indicating the interpretation of the property.");
239 }
240
241 void RNA_def_rna(BlenderRNA *brna)
242 {
243         StructRNA *srna;
244         PropertyRNA *prop;
245
246         /* StructRNA */
247         srna= RNA_def_struct(brna, "StructRNA", "Struct RNA");
248
249         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
250         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
251         RNA_def_property_string_funcs(prop, "rna_StructRNA_name_get", "rna_StructRNA_name_length", NULL);
252         RNA_def_property_ui_text(prop, "Name", "Human readable name.");
253         RNA_def_struct_name_property(srna, prop);
254
255         prop= RNA_def_property(srna, "cname", PROP_STRING, PROP_NONE);
256         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
257         RNA_def_property_string_funcs(prop, "rna_StructRNA_cname_get", "rna_StructRNA_cname_length", NULL);
258         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
259
260         prop= RNA_def_property(srna, "name_property", PROP_POINTER, PROP_NONE);
261         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
262         RNA_def_property_struct_type(prop, "StringPropertyRNA");
263         RNA_def_property_pointer_funcs(prop, "rna_StructRNA_name_property_get", NULL, NULL);
264         RNA_def_property_ui_text(prop, "Name Property", "Property that gives the name of the struct.");
265
266         prop= RNA_def_property(srna, "properties", PROP_COLLECTION, PROP_NONE);
267         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
268         RNA_def_property_collection_funcs(prop, "rna_StructRNA_properties_begin", "rna_StructRNA_properties_next", 0, "rna_StructRNA_properties_get", "rna_StructRNA_properties_type", 0, 0, 0);
269         RNA_def_property_ui_text(prop, "Properties", "Properties in the struct.");
270
271         /* BooleanPropertyRNA */
272         srna= RNA_def_struct(brna, "BooleanPropertyRNA", "Boolean Property");
273         rna_def_property(srna);
274
275         prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_NONE);
276         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
277         RNA_def_property_int_funcs(prop, "rna_PropertyRNA_array_length_get", NULL);
278         RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited.");
279
280         /* IntPropertyRNA */
281         srna= RNA_def_struct(brna, "IntPropertyRNA", "Int Property");
282         rna_def_property(srna);
283
284         prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_NONE);
285         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
286         RNA_def_property_int_funcs(prop, "rna_PropertyRNA_array_length_get", NULL);
287         RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited.");
288
289         /* FloatPropertyRNA */
290         srna= RNA_def_struct(brna, "FloatPropertyRNA", "Float Property");
291         rna_def_property(srna);
292
293         prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_NONE);
294         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
295         RNA_def_property_int_funcs(prop, "rna_PropertyRNA_array_length_get", NULL);
296         RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited.");
297
298         /* StringPropertyRNA */
299         srna= RNA_def_struct(brna, "StringPropertyRNA", "String Property");
300         rna_def_property(srna);
301
302         prop= RNA_def_property(srna, "max_length", PROP_INT, PROP_NONE);
303         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
304         RNA_def_property_int_funcs(prop, "rna_PropertyRNA_max_length_get", NULL);
305         RNA_def_property_ui_text(prop, "Maximum Length", "Maximum length of the string, 0 means unlimited.");
306
307         /* EnumPropertyRNA */
308         srna= RNA_def_struct(brna, "EnumPropertyRNA", "Enum Property");
309         rna_def_property(srna);
310
311         /* PointerPropertyRNA */
312         srna= RNA_def_struct(brna, "PointerPropertyRNA", "Pointer Property");
313         rna_def_property(srna);
314
315         /* CollectionPropertyRNA */
316         srna= RNA_def_struct(brna, "CollectionPropertyRNA", "Collection Property");
317         rna_def_property(srna);
318 }
319
320 void rna_def_builtin_properties(StructRNA *srna)
321 {
322         PropertyRNA *prop;
323
324         prop= RNA_def_property(srna, "rna_properties", PROP_COLLECTION, PROP_NONE);
325         RNA_def_property_flag(prop, PROP_NOT_EDITABLE|PROP_BUILTIN);
326         RNA_def_property_collection_funcs(prop, "rna_builtin_properties_begin", "rna_builtin_properties_next", 0, "rna_builtin_properties_get", "rna_builtin_properties_type", 0, 0, 0);
327         RNA_def_property_ui_text(prop, "Properties", "RNA property collection.");
328
329         prop= RNA_def_property(srna, "rna_type", PROP_POINTER, PROP_NONE);
330         RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
331         RNA_def_property_struct_type(prop, "StructRNA");
332         RNA_def_property_pointer_funcs(prop, "rna_builtin_type_get", NULL, NULL);
333         RNA_def_property_ui_text(prop, "Type", "RNA type definition.");
334 }
335
336 #endif
337