i18n stuff: adds translation_context to RNA structs (used for there ui name), and...
[blender.git] / source / blender / makesrna / intern / rna_rna.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation (2008).
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_rna.c
24  *  \ingroup RNA
25  */
26
27
28 #include <stdlib.h>
29
30 #include "DNA_ID.h"
31
32 #include "RNA_access.h"
33 #include "RNA_define.h"
34
35 #include "rna_internal.h"
36
37 EnumPropertyItem property_type_items[] = {
38         {PROP_BOOLEAN, "BOOLEAN", 0, "Boolean", ""},
39         {PROP_INT, "INT", 0, "Integer", ""},
40         {PROP_FLOAT, "FLOAT", 0, "Float", ""},
41         {PROP_STRING, "STRING", 0, "String", ""},
42         {PROP_ENUM, "ENUM", 0, "Enumeration", ""},
43         {PROP_POINTER, "POINTER", 0, "Pointer", ""},
44         {PROP_COLLECTION, "COLLECTION", 0, "Collection", ""},
45         {0, NULL, 0, NULL, NULL}};
46
47 EnumPropertyItem property_subtype_items[] = {
48         {PROP_NONE, "NONE", 0, "None", ""},
49
50         /* strings */
51         {PROP_FILEPATH, "FILEPATH", 0, "File Path", ""},
52         {PROP_DIRPATH, "DIRPATH", 0, "Directory Path", ""},
53         {PROP_FILENAME, "FILENAME", 0, "File Name", ""},
54         {PROP_TRANSLATE, "TRANSLATE", 0, "Translate", ""},
55
56         /* numbers */
57         {PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned", ""},
58         {PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", ""},
59         {PROP_FACTOR, "FACTOR", 0, "Factor", ""},
60         {PROP_ANGLE, "ANGLE", 0, "Angle", ""},
61         {PROP_TIME, "TIME", 0, "Time", ""},
62         {PROP_DISTANCE, "DISTANCE", 0, "Distance", ""},
63
64         /* number arrays */
65         {PROP_COLOR, "COLOR", 0, "Color", ""},
66         {PROP_TRANSLATION, "TRANSLATION", 0, "Translation", ""},
67         {PROP_DIRECTION, "DIRECTION", 0, "Direction", ""},
68         {PROP_VELOCITY, "VELOCITY", 0, "Velocity", ""},
69         {PROP_ACCELERATION, "ACCELERATION", 0, "Acceleration", ""},
70         {PROP_MATRIX, "MATRIX", 0, "Matrix", ""},
71         {PROP_EULER, "EULER", 0, "Euler Angles", ""},
72         {PROP_QUATERNION, "QUATERNION", 0, "Quaternion", ""},
73         {PROP_AXISANGLE, "AXISANGLE", 0, "Axis-Angle", ""},
74         {PROP_XYZ, "XYZ", 0, "XYZ", ""},
75         {PROP_XYZ_LENGTH, "XYZ_LENGTH", 0, "XYZ Length", ""},
76         {PROP_COLOR_GAMMA, "COLOR_GAMMA", 0, "Color", ""},
77         {PROP_COORDS, "COORDS", 0, "Coordinates", ""},
78
79         /* booleans */
80         {PROP_LAYER, "LAYER", 0, "Layer", ""},
81         {PROP_LAYER_MEMBER, "LAYER_MEMBER", 0, "Layer Member", ""},
82         {0, NULL, 0, NULL, NULL}};
83
84 EnumPropertyItem property_unit_items[] = {
85         {PROP_UNIT_NONE, "NONE", 0, "None", ""},
86         {PROP_UNIT_LENGTH, "LENGTH", 0, "Length", ""},
87         {PROP_UNIT_AREA, "AREA", 0, "Area", ""},
88         {PROP_UNIT_VOLUME, "VOLUME", 0, "Volume", ""},
89         {PROP_UNIT_ROTATION, "ROTATION", 0, "Rotation", ""},
90         {PROP_UNIT_TIME, "TIME", 0, "Time", ""},
91         {PROP_UNIT_VELOCITY, "VELOCITY", 0, "Velocity", ""},
92         {PROP_UNIT_ACCELERATION, "ACCELERATION", 0, "Acceleration", ""},
93         {0, NULL, 0, NULL, NULL}};
94
95 #ifdef RNA_RUNTIME
96 #include "MEM_guardedalloc.h"
97 #include "BLI_utildefines.h"
98 #include "BLI_ghash.h"
99
100 /* Struct */
101
102 static void rna_Struct_identifier_get(PointerRNA *ptr, char *value)
103 {
104         strcpy(value, ((StructRNA*)ptr->data)->identifier);
105 }
106
107 static int rna_Struct_identifier_length(PointerRNA *ptr)
108 {
109         return strlen(((StructRNA*)ptr->data)->identifier);
110 }
111
112 static void rna_Struct_description_get(PointerRNA *ptr, char *value)
113 {
114         strcpy(value, ((StructRNA*)ptr->data)->description);
115 }
116
117 static int rna_Struct_description_length(PointerRNA *ptr)
118 {
119         return strlen(((StructRNA*)ptr->data)->description);
120 }
121
122 static void rna_Struct_name_get(PointerRNA *ptr, char *value)
123 {
124         strcpy(value, ((StructRNA*)ptr->data)->name);
125 }
126
127 static int rna_Struct_name_length(PointerRNA *ptr)
128 {
129         return strlen(((StructRNA*)ptr->data)->name);
130 }
131
132 static void rna_Struct_translation_context_get(PointerRNA *ptr, char *value)
133 {
134         strcpy(value, ((StructRNA*)ptr->data)->translation_context ? ((StructRNA*)ptr->data)->translation_context : "");
135 }
136
137 static int rna_Struct_translation_context_length(PointerRNA *ptr)
138 {
139         return ((StructRNA*)ptr->data)->translation_context ? strlen(((StructRNA*)ptr->data)->translation_context) : 0;
140 }
141
142 static PointerRNA rna_Struct_base_get(PointerRNA *ptr)
143 {
144         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((StructRNA*)ptr->data)->base);
145 }
146
147 static PointerRNA rna_Struct_nested_get(PointerRNA *ptr)
148 {
149         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((StructRNA*)ptr->data)->nested);
150 }
151
152 static PointerRNA rna_Struct_name_property_get(PointerRNA *ptr)
153 {
154         return rna_pointer_inherit_refine(ptr, &RNA_Property, ((StructRNA*)ptr->data)->nameproperty);
155 }
156
157 /* Struct property iteration. This is quite complicated, the purpose is to
158  * iterate over properties of all inheritance levels, and for each struct to
159  * also iterator over id properties not known by RNA. */
160
161 static int rna_idproperty_known(CollectionPropertyIterator *iter, void *data)
162 {
163         IDProperty *idprop = (IDProperty*)data;
164         PropertyRNA *prop;
165         StructRNA *ptype = iter->builtin_parent.type;
166
167         /* function to skip any id properties that are already known by RNA,
168          * for the second loop where we go over unknown id properties */
169         do {
170                 for (prop = ptype->cont.properties.first; prop; prop = prop->next)
171                         if ((prop->flag & PROP_BUILTIN) == 0 && strcmp(prop->identifier, idprop->name) == 0)
172                                 return 1;
173         } while ((ptype = ptype->base));
174
175         return 0;
176 }
177
178 static int rna_property_builtin(CollectionPropertyIterator *UNUSED(iter), void *data)
179 {
180         PropertyRNA *prop = (PropertyRNA*)data;
181
182         /* function to skip builtin rna properties */
183
184         return (prop->flag & PROP_BUILTIN);
185 }
186
187 static int rna_function_builtin(CollectionPropertyIterator *UNUSED(iter), void *data)
188 {
189         FunctionRNA *func = (FunctionRNA*)data;
190
191         /* function to skip builtin rna functions */
192
193         return (func->flag & FUNC_BUILTIN);
194 }
195
196 static void rna_inheritance_next_level_restart(CollectionPropertyIterator *iter, IteratorSkipFunc skip, int funcs)
197 {
198         /* RNA struct inheritance */
199         while (!iter->valid && iter->level > 0) {
200                 StructRNA *srna;
201                 int i;
202
203                 srna = (StructRNA*)iter->parent.data;
204                 iter->level--;
205                 for (i = iter->level; i>0; i--)
206                         srna = srna->base;
207
208                 rna_iterator_listbase_end(iter);
209
210                 if (funcs)
211                         rna_iterator_listbase_begin(iter, &srna->functions, skip);
212                 else
213                         rna_iterator_listbase_begin(iter, &srna->cont.properties, skip);
214         }
215 }
216
217 static void rna_inheritance_properties_listbase_begin(CollectionPropertyIterator *iter, ListBase *lb, IteratorSkipFunc skip)
218 {
219         rna_iterator_listbase_begin(iter, lb, skip);
220         rna_inheritance_next_level_restart(iter, skip, 0);
221 }
222
223 static void rna_inheritance_properties_listbase_next(CollectionPropertyIterator *iter, IteratorSkipFunc skip)
224 {
225         rna_iterator_listbase_next(iter);
226         rna_inheritance_next_level_restart(iter, skip, 0);
227 }
228
229 static void rna_inheritance_functions_listbase_begin(CollectionPropertyIterator *iter, ListBase *lb, IteratorSkipFunc skip)
230 {
231         rna_iterator_listbase_begin(iter, lb, skip);
232         rna_inheritance_next_level_restart(iter, skip, 1);
233 }
234
235 static void rna_inheritance_functions_listbase_next(CollectionPropertyIterator *iter, IteratorSkipFunc skip)
236 {
237         rna_iterator_listbase_next(iter);
238         rna_inheritance_next_level_restart(iter, skip, 1);
239 }
240
241 static void rna_Struct_properties_next(CollectionPropertyIterator *iter)
242 {
243         ListBaseIterator *internal = iter->internal;
244         IDProperty *group;
245
246         if (internal->flag) {
247                 /* id properties */
248                 rna_iterator_listbase_next(iter);
249         }
250         else {
251                 /* regular properties */
252                 rna_inheritance_properties_listbase_next(iter, rna_property_builtin);
253
254                 /* try id properties */
255                 if (!iter->valid) {
256                         group = RNA_struct_idprops(&iter->builtin_parent, 0);
257
258                         if (group) {
259                                 rna_iterator_listbase_end(iter);
260                                 rna_iterator_listbase_begin(iter, &group->data.group, rna_idproperty_known);
261                                 internal = iter->internal;
262                                 internal->flag = 1;
263                         }
264                 }
265         }
266 }
267
268 static void rna_Struct_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
269 {
270         StructRNA *srna;
271
272         /* here ptr->data should always be the same as iter->parent.type */
273         srna = (StructRNA *)ptr->data;
274
275         while (srna->base) {
276                 iter->level++;
277                 srna = srna->base;
278         }
279
280         rna_inheritance_properties_listbase_begin(iter, &srna->cont.properties, rna_property_builtin);
281 }
282
283 static PointerRNA rna_Struct_properties_get(CollectionPropertyIterator *iter)
284 {
285         ListBaseIterator *internal = iter->internal;
286
287         /* we return either PropertyRNA* or IDProperty*, the rna_access.c
288          * functions can handle both as PropertyRNA* with some tricks */
289         return rna_pointer_inherit_refine(&iter->parent, &RNA_Property, internal->link);
290 }
291
292 static void rna_Struct_functions_next(CollectionPropertyIterator *iter)
293 {
294         rna_inheritance_functions_listbase_next(iter, rna_function_builtin);
295 }
296
297 static void rna_Struct_functions_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
298 {
299         StructRNA *srna;
300
301         /* here ptr->data should always be the same as iter->parent.type */
302         srna = (StructRNA *)ptr->data;
303
304         while (srna->base) {
305                 iter->level++;
306                 srna = srna->base;
307         }
308
309         rna_inheritance_functions_listbase_begin(iter, &srna->functions, rna_function_builtin);
310 }
311
312 static PointerRNA rna_Struct_functions_get(CollectionPropertyIterator *iter)
313 {
314         ListBaseIterator *internal = iter->internal;
315
316         /* we return either PropertyRNA* or IDProperty*, the rna_access.c
317          * functions can handle both as PropertyRNA* with some tricks */
318         return rna_pointer_inherit_refine(&iter->parent, &RNA_Function, internal->link);
319 }
320
321 /* Builtin properties iterator re-uses the Struct properties iterator, only
322  * difference is that we need to set the ptr data to the type of the struct
323  * whose properties we want to iterate over. */
324
325 void rna_builtin_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
326 {
327         PointerRNA newptr;
328
329         /* we create a new pointer with the type as the data */
330         newptr.type = &RNA_Struct;
331         newptr.data = ptr->type;
332
333         if (ptr->type->flag & STRUCT_ID)
334                 newptr.id.data = ptr->data;
335         else
336                 newptr.id.data = NULL;
337
338         iter->parent = newptr;
339         iter->builtin_parent = *ptr;
340
341         rna_Struct_properties_begin(iter, &newptr);
342 }
343
344 void rna_builtin_properties_next(CollectionPropertyIterator *iter)
345 {
346         rna_Struct_properties_next(iter);
347 }
348
349 PointerRNA rna_builtin_properties_get(CollectionPropertyIterator *iter)
350 {
351         return rna_Struct_properties_get(iter);
352 }
353
354 int rna_builtin_properties_lookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
355 {
356         StructRNA *srna;
357         PropertyRNA *prop;
358         PointerRNA propptr = {{NULL}};
359
360         srna = ptr->type;
361
362         do {
363                 if (srna->cont.prophash) {
364                         prop = BLI_ghash_lookup(srna->cont.prophash, (void*)key);
365
366                         if (prop) {
367                                 propptr.type = &RNA_Property;
368                                 propptr.data = prop;
369
370                                 *r_ptr = propptr;
371                                 return TRUE;
372                         }
373                 }
374                 else {
375                         for (prop = srna->cont.properties.first; prop; prop = prop->next) {
376                                 if (!(prop->flag & PROP_BUILTIN) && strcmp(prop->identifier, key) == 0) {
377                                         propptr.type = &RNA_Property;
378                                         propptr.data = prop;
379
380                                         *r_ptr = propptr;
381                                         return TRUE;
382                                 }
383                         }
384                 }
385         } while ((srna = srna->base));
386
387         /* this was used pre 2.5beta0, now ID property access uses python's
388          * getitem style access
389          * - ob["foo"] rather than ob.foo */
390 #if 0
391         if (ptr->data) {
392                 IDProperty *group, *idp;
393
394                 group = RNA_struct_idprops(ptr, 0);
395
396                 if (group) {
397                         for (idp = group->data.group.first; idp; idp = idp->next) {
398                                 if (strcmp(idp->name, key) == 0) {
399                                         propptr.type = &RNA_Property;
400                                         propptr.data = idp;
401
402                                         *r_ptr = propptr;
403                                         return TRUE;
404                                 }
405                         }
406                 }
407         }
408 #endif
409         return FALSE;
410 }
411
412 PointerRNA rna_builtin_type_get(PointerRNA *ptr)
413 {
414         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ptr->type);
415 }
416
417 /* Property */
418
419 static StructRNA *rna_Property_refine(PointerRNA *ptr)
420 {
421         PropertyRNA *prop = (PropertyRNA*)ptr->data;
422
423         rna_idproperty_check(&prop, ptr); /* XXX ptr? */
424
425         switch (prop->type) {
426                 case PROP_BOOLEAN: return &RNA_BoolProperty;
427                 case PROP_INT: return &RNA_IntProperty;
428                 case PROP_FLOAT: return &RNA_FloatProperty;
429                 case PROP_STRING: return &RNA_StringProperty;
430                 case PROP_ENUM: return &RNA_EnumProperty;
431                 case PROP_POINTER: return &RNA_PointerProperty;
432                 case PROP_COLLECTION: return &RNA_CollectionProperty;
433                 default: return &RNA_Property;
434         }
435 }
436
437 static void rna_Property_identifier_get(PointerRNA *ptr, char *value)
438 {
439         PropertyRNA *prop = (PropertyRNA*)ptr->data;
440         rna_idproperty_check(&prop, ptr);
441         strcpy(value, ((PropertyRNA*)prop)->identifier);
442 }
443
444 static int rna_Property_identifier_length(PointerRNA *ptr)
445 {
446         PropertyRNA *prop = (PropertyRNA*)ptr->data;
447         rna_idproperty_check(&prop, ptr);
448         return strlen(prop->identifier);
449 }
450
451 static void rna_Property_name_get(PointerRNA *ptr, char *value)
452 {
453         PropertyRNA *prop = (PropertyRNA*)ptr->data;
454         rna_idproperty_check(&prop, ptr);
455         strcpy(value, prop->name);
456 }
457
458 static int rna_Property_name_length(PointerRNA *ptr)
459 {
460         PropertyRNA *prop = (PropertyRNA*)ptr->data;
461         rna_idproperty_check(&prop, ptr);
462         return strlen(prop->name);
463 }
464
465 static void rna_Property_description_get(PointerRNA *ptr, char *value)
466 {
467         PropertyRNA *prop = (PropertyRNA*)ptr->data;
468         rna_idproperty_check(&prop, ptr);
469         strcpy(value, prop->description ? prop->description:"");
470 }
471 static int rna_Property_description_length(PointerRNA *ptr)
472 {
473         PropertyRNA *prop = (PropertyRNA*)ptr->data;
474         rna_idproperty_check(&prop, ptr);
475         return prop->description ? strlen(prop->description) : 0;
476 }
477
478 static void rna_Property_translation_context_get(PointerRNA *ptr, char *value)
479 {
480         PropertyRNA *prop = (PropertyRNA*)ptr->data;
481         rna_idproperty_check(&prop, ptr);
482         strcpy(value, prop->translation_context ? prop->translation_context:"");
483 }
484
485 static int rna_Property_translation_context_length(PointerRNA *ptr)
486 {
487         PropertyRNA *prop = (PropertyRNA*)ptr->data;
488         rna_idproperty_check(&prop, ptr);
489         return prop->translation_context ? strlen(prop->translation_context) : 0;
490 }
491
492 static int rna_Property_type_get(PointerRNA *ptr)
493 {
494         PropertyRNA *prop = (PropertyRNA*)ptr->data;
495         rna_idproperty_check(&prop, ptr);
496         return prop->type;
497 }
498
499 static int rna_Property_subtype_get(PointerRNA *ptr)
500 {
501         PropertyRNA *prop = (PropertyRNA*)ptr->data;
502         rna_idproperty_check(&prop, ptr);
503         return prop->subtype;
504 }
505
506 static PointerRNA rna_Property_srna_get(PointerRNA *ptr)
507 {
508         PropertyRNA *prop = (PropertyRNA*)ptr->data;
509         rna_idproperty_check(&prop, ptr);
510         return rna_pointer_inherit_refine(ptr, &RNA_Struct, prop->srna);
511 }
512
513 static int rna_Property_unit_get(PointerRNA *ptr)
514 {
515         PropertyRNA *prop = (PropertyRNA*)ptr->data;
516         rna_idproperty_check(&prop, ptr);
517         return RNA_SUBTYPE_UNIT(prop->subtype);
518 }
519
520 static int rna_Property_readonly_get(PointerRNA *ptr)
521 {
522         PropertyRNA *prop = (PropertyRNA*)ptr->data;
523
524         /* dont use this becaure it will call functions that check the internal
525          * data for introspection we only need to know if it can be edited so the
526          * flag is better for this */
527 /*      return RNA_property_editable(ptr, prop); */
528         return prop->flag & PROP_EDITABLE ? 0:1;
529 }
530
531 static int rna_Property_animatable_get(PointerRNA *ptr)
532 {
533         PropertyRNA *prop = (PropertyRNA*)ptr->data;
534
535         return (prop->flag & PROP_ANIMATABLE) != 0;
536 }
537
538 static int rna_Property_use_output_get(PointerRNA *ptr)
539 {
540         PropertyRNA *prop = (PropertyRNA*)ptr->data;
541         return prop->flag & PROP_OUTPUT ? 1:0;
542 }
543
544 static int rna_Property_is_required_get(PointerRNA *ptr)
545 {
546         PropertyRNA *prop = (PropertyRNA*)ptr->data;
547         return prop->flag & PROP_REQUIRED ? 1:0;
548 }
549
550 static int rna_Property_is_never_none_get(PointerRNA *ptr)
551 {
552         PropertyRNA *prop = (PropertyRNA*)ptr->data;
553         return prop->flag & PROP_NEVER_NULL ? 1:0;
554 }
555
556 static int rna_Property_is_hidden_get(PointerRNA *ptr)
557 {
558         PropertyRNA *prop = (PropertyRNA*)ptr->data;
559         return prop->flag & PROP_HIDDEN ? 1:0;
560 }
561
562 static int rna_Property_is_skip_save_get(PointerRNA *ptr)
563 {
564         PropertyRNA *prop = (PropertyRNA*)ptr->data;
565         return prop->flag & PROP_SKIP_SAVE ? 1:0;
566 }
567
568
569 static int rna_Property_is_enum_flag_get(PointerRNA *ptr)
570 {
571         PropertyRNA *prop = (PropertyRNA*)ptr->data;
572         return prop->flag & PROP_ENUM_FLAG ? 1:0;
573 }
574
575 static int rna_Property_array_length_get(PointerRNA *ptr)
576 {
577         PropertyRNA *prop = (PropertyRNA*)ptr->data;
578         rna_idproperty_check(&prop, ptr);
579         return prop->totarraylength;
580 }
581
582 static int rna_Property_registered_get(PointerRNA *ptr)
583 {
584         PropertyRNA *prop = (PropertyRNA*)ptr->data;
585         return prop->flag & PROP_REGISTER;
586 }
587
588 static int rna_Property_registered_optional_get(PointerRNA *ptr)
589 {
590         PropertyRNA *prop = (PropertyRNA*)ptr->data;
591         return prop->flag & PROP_REGISTER_OPTIONAL;
592 }
593
594 static int rna_Property_runtime_get(PointerRNA *ptr)
595 {
596         PropertyRNA *prop = (PropertyRNA*)ptr->data;
597         return prop->flag & PROP_RUNTIME;
598 }
599
600
601 static int rna_BoolProperty_default_get(PointerRNA *ptr)
602 {
603         PropertyRNA *prop = (PropertyRNA*)ptr->data;
604         rna_idproperty_check(&prop, ptr);
605         return ((BoolPropertyRNA*)prop)->defaultvalue;
606 }
607
608 static int rna_IntProperty_default_get(PointerRNA *ptr)
609 {
610         PropertyRNA *prop = (PropertyRNA*)ptr->data;
611         rna_idproperty_check(&prop, ptr);
612         return ((IntPropertyRNA*)prop)->defaultvalue;
613 }
614 /* int/float/bool */
615 static int rna_NumberProperty_default_array_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
616 {
617         PropertyRNA *prop = (PropertyRNA*)ptr->data;
618         rna_idproperty_check(&prop, ptr);
619
620         length[0] = prop->totarraylength;
621
622         return length[0];
623 }
624 static void rna_IntProperty_default_array_get(PointerRNA *ptr, int *values)
625 {
626         PropertyRNA *prop = (PropertyRNA*)ptr->data;
627         IntPropertyRNA *nprop = (IntPropertyRNA*)prop;
628         rna_idproperty_check(&prop, ptr);
629
630         if (nprop->defaultarray) {
631                 memcpy(values, nprop->defaultarray, prop->totarraylength * sizeof(int));
632         }
633         else {
634                 int i;
635                 for (i = 0; i < prop->totarraylength; i++)
636                         values[i] = nprop->defaultvalue;
637         }
638 }
639 static void rna_BoolProperty_default_array_get(PointerRNA *ptr, int *values)
640 {
641         PropertyRNA *prop = (PropertyRNA*)ptr->data;
642         BoolPropertyRNA *nprop = (BoolPropertyRNA*)prop;
643         rna_idproperty_check(&prop, ptr);
644
645         if (nprop->defaultarray) {
646                 memcpy(values, nprop->defaultarray, prop->totarraylength * sizeof(int));
647         }
648         else {
649                 int i;
650                 for (i = 0; i < prop->totarraylength; i++)
651                         values[i] = nprop->defaultvalue;
652         }
653 }
654 static void rna_FloatProperty_default_array_get(PointerRNA *ptr, float *values)
655 {
656         PropertyRNA *prop = (PropertyRNA*)ptr->data;
657         FloatPropertyRNA *nprop = (FloatPropertyRNA*)prop;
658         rna_idproperty_check(&prop, ptr);
659
660         if (nprop->defaultarray) {
661                 memcpy(values, nprop->defaultarray, prop->totarraylength * sizeof(float));
662         }
663         else {
664                 int i;
665                 for (i = 0; i < prop->totarraylength; i++)
666                         values[i] = nprop->defaultvalue;
667         }
668 }
669
670 static int rna_IntProperty_hard_min_get(PointerRNA *ptr)
671 {
672         PropertyRNA *prop = (PropertyRNA*)ptr->data;
673         rna_idproperty_check(&prop, ptr);
674         return ((IntPropertyRNA*)prop)->hardmin;
675 }
676
677 static int rna_IntProperty_hard_max_get(PointerRNA *ptr)
678 {
679         PropertyRNA *prop = (PropertyRNA*)ptr->data;
680         rna_idproperty_check(&prop, ptr);
681         return ((IntPropertyRNA*)prop)->hardmax;
682 }
683
684 static int rna_IntProperty_soft_min_get(PointerRNA *ptr)
685 {
686         PropertyRNA *prop = (PropertyRNA*)ptr->data;
687         rna_idproperty_check(&prop, ptr);
688         return ((IntPropertyRNA*)prop)->softmin;
689 }
690
691 static int rna_IntProperty_soft_max_get(PointerRNA *ptr)
692 {
693         PropertyRNA *prop = (PropertyRNA*)ptr->data;
694         rna_idproperty_check(&prop, ptr);
695         return ((IntPropertyRNA*)prop)->softmax;
696 }
697
698 static int rna_IntProperty_step_get(PointerRNA *ptr)
699 {
700         PropertyRNA *prop = (PropertyRNA*)ptr->data;
701         rna_idproperty_check(&prop, ptr);
702         return ((IntPropertyRNA*)prop)->step;
703 }
704
705 static float rna_FloatProperty_default_get(PointerRNA *ptr)
706 {
707         PropertyRNA *prop = (PropertyRNA*)ptr->data;
708         rna_idproperty_check(&prop, ptr);
709         return ((FloatPropertyRNA*)prop)->defaultvalue;
710 }
711 static float rna_FloatProperty_hard_min_get(PointerRNA *ptr)
712 {
713         PropertyRNA *prop = (PropertyRNA*)ptr->data;
714         rna_idproperty_check(&prop, ptr);
715         return ((FloatPropertyRNA*)prop)->hardmin;
716 }
717
718 static float rna_FloatProperty_hard_max_get(PointerRNA *ptr)
719 {
720         PropertyRNA *prop = (PropertyRNA*)ptr->data;
721         rna_idproperty_check(&prop, ptr);
722         return ((FloatPropertyRNA*)prop)->hardmax;
723 }
724
725 static float rna_FloatProperty_soft_min_get(PointerRNA *ptr)
726 {
727         PropertyRNA *prop = (PropertyRNA*)ptr->data;
728         rna_idproperty_check(&prop, ptr);
729         return ((FloatPropertyRNA*)prop)->softmin;
730 }
731
732 static float rna_FloatProperty_soft_max_get(PointerRNA *ptr)
733 {
734         PropertyRNA *prop = (PropertyRNA*)ptr->data;
735         rna_idproperty_check(&prop, ptr);
736         return ((FloatPropertyRNA*)prop)->softmax;
737 }
738
739 static float rna_FloatProperty_step_get(PointerRNA *ptr)
740 {
741         PropertyRNA *prop = (PropertyRNA*)ptr->data;
742         rna_idproperty_check(&prop, ptr);
743         return ((FloatPropertyRNA*)prop)->step;
744 }
745
746 static int rna_FloatProperty_precision_get(PointerRNA *ptr)
747 {
748         PropertyRNA *prop = (PropertyRNA*)ptr->data;
749         rna_idproperty_check(&prop, ptr);
750         return ((FloatPropertyRNA*)prop)->precision;
751 }
752
753 static void rna_StringProperty_default_get(PointerRNA *ptr, char *value)
754 {
755         PropertyRNA *prop = (PropertyRNA*)ptr->data;
756         rna_idproperty_check(&prop, ptr);
757         strcpy(value, ((StringPropertyRNA*)prop)->defaultvalue);
758 }
759 static int rna_StringProperty_default_length(PointerRNA *ptr)
760 {
761         PropertyRNA *prop = (PropertyRNA*)ptr->data;
762         rna_idproperty_check(&prop, ptr);
763         return strlen(((StringPropertyRNA*)prop)->defaultvalue);
764 }
765
766 static int rna_StringProperty_max_length_get(PointerRNA *ptr)
767 {
768         PropertyRNA *prop = (PropertyRNA*)ptr->data;
769         rna_idproperty_check(&prop, ptr);
770         return ((StringPropertyRNA*)prop)->maxlength;
771 }
772
773 static EnumPropertyItem *rna_EnumProperty_default_itemf(bContext *C, PointerRNA *ptr, PropertyRNA *prop_parent, int *free)
774 {
775         PropertyRNA *prop = (PropertyRNA*)ptr->data;
776         EnumPropertyRNA *eprop;
777
778         rna_idproperty_check(&prop, ptr);
779         eprop = (EnumPropertyRNA*)prop;
780
781         /* incompatible default attributes */
782         if ((prop_parent->flag & PROP_ENUM_FLAG) != (prop->flag & PROP_ENUM_FLAG)) {
783                 return NULL;
784         }
785
786         if (            (eprop->itemf == NULL) ||
787                         (eprop->itemf == rna_EnumProperty_default_itemf) ||
788                         (ptr->type == &RNA_EnumProperty) ||
789                         (C == NULL))
790         {
791                 return eprop->item;
792         }
793
794         return eprop->itemf(C, ptr, prop, free);
795 }
796
797 /* XXX - not sure this is needed? */
798 static int rna_EnumProperty_default_get(PointerRNA *ptr)
799 {
800         PropertyRNA *prop = (PropertyRNA*)ptr->data;
801         rna_idproperty_check(&prop, ptr);
802         return ((EnumPropertyRNA*)prop)->defaultvalue;
803 }
804
805 static int rna_enum_check_separator(CollectionPropertyIterator *UNUSED(iter), void *data)
806 {
807         EnumPropertyItem *item = (EnumPropertyItem*)data;
808
809         return (item->identifier[0] == 0);
810 }
811
812 static void rna_EnumProperty_items_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
813 {
814         PropertyRNA *prop = (PropertyRNA*)ptr->data;
815         /* EnumPropertyRNA *eprop;  *//* UNUSED */
816         EnumPropertyItem *item = NULL;
817         int totitem, free = 0;
818         
819         rna_idproperty_check(&prop, ptr);
820         /* eprop= (EnumPropertyRNA*)prop; */
821         
822         RNA_property_enum_items(NULL, ptr, prop, &item, &totitem, &free);
823         rna_iterator_array_begin(iter, (void*)item, sizeof(EnumPropertyItem), totitem, free, rna_enum_check_separator);
824 }
825
826 static void rna_EnumPropertyItem_identifier_get(PointerRNA *ptr, char *value)
827 {
828         strcpy(value, ((EnumPropertyItem*)ptr->data)->identifier);
829 }
830
831 static int rna_EnumPropertyItem_identifier_length(PointerRNA *ptr)
832 {
833         return strlen(((EnumPropertyItem*)ptr->data)->identifier);
834 }
835
836 static void rna_EnumPropertyItem_name_get(PointerRNA *ptr, char *value)
837 {
838         strcpy(value, ((EnumPropertyItem*)ptr->data)->name);
839 }
840
841 static int rna_EnumPropertyItem_name_length(PointerRNA *ptr)
842 {
843         return strlen(((EnumPropertyItem*)ptr->data)->name);
844 }
845
846 static void rna_EnumPropertyItem_description_get(PointerRNA *ptr, char *value)
847 {
848         EnumPropertyItem *eprop = (EnumPropertyItem*)ptr->data;
849
850         if (eprop->description)
851                 strcpy(value, eprop->description);
852         else
853                 value[0] = '\0';
854 }
855
856 static int rna_EnumPropertyItem_description_length(PointerRNA *ptr)
857 {
858         EnumPropertyItem *eprop = (EnumPropertyItem*)ptr->data;
859
860         if (eprop->description)
861                 return strlen(eprop->description);
862         else
863                 return 0;
864 }
865
866 static int rna_EnumPropertyItem_value_get(PointerRNA *ptr)
867 {
868         return ((EnumPropertyItem*)ptr->data)->value;
869 }
870
871 static PointerRNA rna_PointerProperty_fixed_type_get(PointerRNA *ptr)
872 {
873         PropertyRNA *prop = (PropertyRNA*)ptr->data;
874         rna_idproperty_check(&prop, ptr);
875         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((PointerPropertyRNA*)prop)->type);
876 }
877
878 static PointerRNA rna_CollectionProperty_fixed_type_get(PointerRNA *ptr)
879 {
880         PropertyRNA *prop = (PropertyRNA*)ptr->data;
881         rna_idproperty_check(&prop, ptr);
882         return rna_pointer_inherit_refine(ptr, &RNA_Struct, ((CollectionPropertyRNA*)prop)->item_type);
883 }
884
885 /* Function */
886
887 static void rna_Function_identifier_get(PointerRNA *ptr, char *value)
888 {
889         strcpy(value, ((FunctionRNA*)ptr->data)->identifier);
890 }
891
892 static int rna_Function_identifier_length(PointerRNA *ptr)
893 {
894         return strlen(((FunctionRNA*)ptr->data)->identifier);
895 }
896
897 static void rna_Function_description_get(PointerRNA *ptr, char *value)
898 {
899         strcpy(value, ((FunctionRNA*)ptr->data)->description);
900 }
901
902 static int rna_Function_description_length(PointerRNA *ptr)
903 {
904         return strlen(((FunctionRNA*)ptr->data)->description);
905 }
906
907 static void rna_Function_parameters_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
908 {
909         rna_iterator_listbase_begin(iter, &((FunctionRNA*)ptr->data)->cont.properties, rna_property_builtin);
910 }
911
912 static int rna_Function_registered_get(PointerRNA *ptr)
913 {
914         FunctionRNA *func = (FunctionRNA*)ptr->data;
915         return func->flag & FUNC_REGISTER;
916 }
917
918 static int rna_Function_registered_optional_get(PointerRNA *ptr)
919 {
920         FunctionRNA *func = (FunctionRNA*)ptr->data;
921         return func->flag & FUNC_REGISTER_OPTIONAL;
922 }
923
924 static int rna_Function_no_self_get(PointerRNA *ptr)
925 {
926         FunctionRNA *func = (FunctionRNA*)ptr->data;
927         return !(func->flag & FUNC_NO_SELF);
928 }
929
930 /* Blender RNA */
931
932 static void rna_BlenderRNA_structs_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
933 {
934         rna_iterator_listbase_begin(iter, &((BlenderRNA*)ptr->data)->structs, NULL);
935 }
936
937 /* optional, for faster lookups */
938 static int rna_BlenderRNA_structs_length(PointerRNA *ptr)
939 {
940         return BLI_countlist(&((BlenderRNA*)ptr->data)->structs);
941 }
942 static int rna_BlenderRNA_structs_lookup_int(PointerRNA *ptr, int index, PointerRNA *r_ptr)
943 {
944         StructRNA *srna = BLI_findlink(&((BlenderRNA*)ptr->data)->structs, index);
945
946         if (srna) {
947                 RNA_pointer_create(NULL, &RNA_Struct, srna, r_ptr);
948                 return TRUE;
949         }
950         else {
951                 return FALSE;
952         }
953 }
954 static int rna_BlenderRNA_structs_lookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
955 {
956         StructRNA *srna = ((BlenderRNA*)ptr->data)->structs.first;
957         for (; srna; srna = srna->cont.next) {
958                 if (key[0] == srna->identifier[0] && strcmp(key, srna->identifier) == 0) {
959                         RNA_pointer_create(NULL, &RNA_Struct, srna, r_ptr);
960                         return TRUE;
961                 }
962         }
963
964         return FALSE;
965 }
966
967
968 #else
969
970 static void rna_def_struct(BlenderRNA *brna)
971 {
972         StructRNA *srna;
973         PropertyRNA *prop;
974
975         srna = RNA_def_struct(brna, "Struct", NULL);
976         RNA_def_struct_ui_text(srna, "Struct Definition", "RNA structure definition");
977         RNA_def_struct_ui_icon(srna, ICON_RNA);
978
979         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
980         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
981         RNA_def_property_string_funcs(prop, "rna_Struct_name_get", "rna_Struct_name_length", NULL);
982         RNA_def_property_ui_text(prop, "Name", "Human readable name");
983
984         prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
985         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
986         RNA_def_property_string_funcs(prop, "rna_Struct_identifier_get", "rna_Struct_identifier_length", NULL);
987         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
988         RNA_def_struct_name_property(srna, prop);
989         
990         prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
991         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
992         RNA_def_property_string_funcs(prop, "rna_Struct_description_get", "rna_Struct_description_length", NULL);
993         RNA_def_property_ui_text(prop, "Description", "Description of the Struct's purpose");
994         
995         prop = RNA_def_property(srna, "translation_context", PROP_STRING, PROP_NONE);
996         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
997         RNA_def_property_string_funcs(prop, "rna_Struct_translation_context_get", "rna_Struct_translation_context_length", NULL);
998         RNA_def_property_ui_text(prop, "Translation Context", "Translation context of the struct's name");
999         
1000         prop = RNA_def_property(srna, "base", PROP_POINTER, PROP_NONE);
1001         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1002         RNA_def_property_struct_type(prop, "Struct");
1003         RNA_def_property_pointer_funcs(prop, "rna_Struct_base_get", NULL, NULL, NULL);
1004         RNA_def_property_ui_text(prop, "Base", "Struct definition this is derived from");
1005
1006         prop = RNA_def_property(srna, "nested", PROP_POINTER, PROP_NONE);
1007         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1008         RNA_def_property_struct_type(prop, "Struct");
1009         RNA_def_property_pointer_funcs(prop, "rna_Struct_nested_get", NULL, NULL, NULL);
1010         RNA_def_property_ui_text(prop, "Nested", "Struct in which this struct is always nested, and to which it logically belongs");
1011
1012         prop = RNA_def_property(srna, "name_property", PROP_POINTER, PROP_NONE);
1013         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1014         RNA_def_property_struct_type(prop, "StringProperty");
1015         RNA_def_property_pointer_funcs(prop, "rna_Struct_name_property_get", NULL, NULL, NULL);
1016         RNA_def_property_ui_text(prop, "Name Property", "Property that gives the name of the struct");
1017
1018         prop = RNA_def_property(srna, "properties", PROP_COLLECTION, PROP_NONE);
1019         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1020         RNA_def_property_struct_type(prop, "Property");
1021         RNA_def_property_collection_funcs(prop, "rna_Struct_properties_begin", "rna_Struct_properties_next", "rna_iterator_listbase_end", "rna_Struct_properties_get", NULL, NULL, NULL, NULL);
1022         RNA_def_property_ui_text(prop, "Properties", "Properties in the struct");
1023
1024         prop = RNA_def_property(srna, "functions", PROP_COLLECTION, PROP_NONE);
1025         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1026         RNA_def_property_struct_type(prop, "Function");
1027         RNA_def_property_collection_funcs(prop, "rna_Struct_functions_begin", "rna_Struct_functions_next", "rna_iterator_listbase_end", "rna_Struct_functions_get", NULL, NULL, NULL, NULL);
1028         RNA_def_property_ui_text(prop, "Functions", "");
1029 }
1030
1031 static void rna_def_property(BlenderRNA *brna)
1032 {
1033         StructRNA *srna;
1034         PropertyRNA *prop;
1035         static EnumPropertyItem subtype_items[] = {
1036                 {PROP_NONE, "NONE", 0, "None", ""},
1037                 {PROP_FILEPATH, "FILE_PATH", 0, "File Path", ""},
1038                 {PROP_DIRPATH, "DIRECTORY_PATH", 0, "Directory Path", ""},
1039                 {PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned Number", ""},
1040                 {PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", ""},
1041                 {PROP_FACTOR, "FACTOR", 0, "Factor", ""},
1042                 {PROP_ANGLE, "ANGLE", 0, "Angle", ""},
1043                 {PROP_TIME, "TIME", 0, "Time", ""},
1044                 {PROP_DISTANCE, "DISTANCE", 0, "Distance", ""},
1045                 {PROP_COLOR, "COLOR", 0, "Color", ""},
1046                 {PROP_TRANSLATION, "TRANSLATION", 0, "Translation", ""},
1047                 {PROP_DIRECTION, "DIRECTION", 0, "Direction", ""},
1048                 {PROP_MATRIX, "MATRIX", 0, "Matrix", ""},
1049                 {PROP_EULER, "EULER", 0, "Euler", ""},
1050                 {PROP_QUATERNION, "QUATERNION", 0, "Quaternion", ""},
1051                 {PROP_XYZ, "XYZ", 0, "XYZ", ""},
1052                 {PROP_COLOR_GAMMA, "COLOR_GAMMA", 0, "Gamma Corrected Color", ""},
1053                 {PROP_COORDS, "COORDINATES", 0, "Vector Coordinates", ""},
1054                 {PROP_LAYER, "LAYER", 0, "Layer", ""},
1055                 {PROP_LAYER_MEMBER, "LAYER_MEMBERSHIP", 0, "Layer Membership", ""},
1056                 {0, NULL, 0, NULL, NULL}};
1057
1058         srna = RNA_def_struct(brna, "Property", NULL);
1059         RNA_def_struct_ui_text(srna, "Property Definition", "RNA property definition");
1060         RNA_def_struct_refine_func(srna, "rna_Property_refine");
1061         RNA_def_struct_ui_icon(srna, ICON_RNA);
1062
1063         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1064         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1065         RNA_def_property_string_funcs(prop, "rna_Property_name_get", "rna_Property_name_length", NULL);
1066         RNA_def_property_ui_text(prop, "Name", "Human readable name");
1067
1068         prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
1069         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1070         RNA_def_property_string_funcs(prop, "rna_Property_identifier_get", "rna_Property_identifier_length", NULL);
1071         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
1072         RNA_def_struct_name_property(srna, prop);
1073                 
1074         prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
1075         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1076         RNA_def_property_string_funcs(prop, "rna_Property_description_get", "rna_Property_description_length", NULL);
1077         RNA_def_property_ui_text(prop, "Description", "Description of the property for tooltips");
1078
1079         prop = RNA_def_property(srna, "translation_context", PROP_STRING, PROP_NONE);
1080         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1081         RNA_def_property_string_funcs(prop, "rna_Property_translation_context_get", "rna_Property_translation_context_length", NULL);
1082         RNA_def_property_ui_text(prop, "Translation Context", "Translation context of the property's name");
1083
1084         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1085         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1086         RNA_def_property_enum_items(prop, property_type_items);
1087         RNA_def_property_enum_funcs(prop, "rna_Property_type_get", NULL, NULL);
1088         RNA_def_property_ui_text(prop, "Type", "Data type of the property");
1089
1090         prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
1091         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1092         RNA_def_property_enum_items(prop, subtype_items);
1093         RNA_def_property_enum_funcs(prop, "rna_Property_subtype_get", NULL, NULL);
1094         RNA_def_property_ui_text(prop, "Subtype", "Semantic interpretation of the property");
1095
1096         prop = RNA_def_property(srna, "srna", PROP_POINTER, PROP_NONE);
1097         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1098         RNA_def_property_struct_type(prop, "Struct");
1099         RNA_def_property_pointer_funcs(prop, "rna_Property_srna_get", NULL, NULL, NULL);
1100         RNA_def_property_ui_text(prop, "Base", "Struct definition used for properties assigned to this item");
1101
1102         prop = RNA_def_property(srna, "unit", PROP_ENUM, PROP_NONE);
1103         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1104         RNA_def_property_enum_items(prop, property_unit_items);
1105         RNA_def_property_enum_funcs(prop, "rna_Property_unit_get", NULL, NULL);
1106         RNA_def_property_ui_text(prop, "Unit", "Type of units for this property");
1107
1108         prop = RNA_def_property(srna, "is_readonly", PROP_BOOLEAN, PROP_NONE);
1109         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1110         RNA_def_property_boolean_funcs(prop, "rna_Property_readonly_get", NULL);
1111         RNA_def_property_ui_text(prop, "Read Only", "Property is editable through RNA");
1112
1113         prop = RNA_def_property(srna, "is_animatable", PROP_BOOLEAN, PROP_NONE);
1114         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1115         RNA_def_property_boolean_funcs(prop, "rna_Property_animatable_get", NULL);
1116         RNA_def_property_ui_text(prop, "Animatable", "Property is animatable through RNA");
1117
1118         prop = RNA_def_property(srna, "is_required", PROP_BOOLEAN, PROP_NONE);
1119         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1120         RNA_def_property_boolean_funcs(prop, "rna_Property_is_required_get", NULL);
1121         RNA_def_property_ui_text(prop, "Required", "False when this property is an optional argument in an RNA function");
1122
1123         prop = RNA_def_property(srna, "is_never_none", PROP_BOOLEAN, PROP_NONE);
1124         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1125         RNA_def_property_boolean_funcs(prop, "rna_Property_is_never_none_get", NULL);
1126         RNA_def_property_ui_text(prop, "Never None", "True when this value can't be set to None");
1127
1128         prop = RNA_def_property(srna, "is_hidden", PROP_BOOLEAN, PROP_NONE);
1129         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1130         RNA_def_property_boolean_funcs(prop, "rna_Property_is_hidden_get", NULL);
1131         RNA_def_property_ui_text(prop, "Hidden", "True when the property is hidden");
1132
1133         prop = RNA_def_property(srna, "is_skip_save", PROP_BOOLEAN, PROP_NONE);
1134         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1135         RNA_def_property_boolean_funcs(prop, "rna_Property_is_skip_save_get", NULL);
1136         RNA_def_property_ui_text(prop, "Skip Save", "True when the property is not saved in presets");
1137
1138         prop = RNA_def_property(srna, "is_output", PROP_BOOLEAN, PROP_NONE);
1139         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1140         RNA_def_property_boolean_funcs(prop, "rna_Property_use_output_get", NULL);
1141         RNA_def_property_ui_text(prop, "Return", "True when this property is an output value from an RNA function");
1142
1143         prop = RNA_def_property(srna, "is_registered", PROP_BOOLEAN, PROP_NONE);
1144         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1145         RNA_def_property_boolean_funcs(prop, "rna_Property_registered_get", NULL);
1146         RNA_def_property_ui_text(prop, "Registered", "Property is registered as part of type registration");
1147
1148         prop = RNA_def_property(srna, "is_registered_optional", PROP_BOOLEAN, PROP_NONE);
1149         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1150         RNA_def_property_boolean_funcs(prop, "rna_Property_registered_optional_get", NULL);
1151         RNA_def_property_ui_text(prop, "Registered Optionally", "Property is optionally registered as part of type registration");
1152         
1153         prop = RNA_def_property(srna, "is_runtime", PROP_BOOLEAN, PROP_NONE);
1154         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1155         RNA_def_property_boolean_funcs(prop, "rna_Property_runtime_get", NULL);
1156         RNA_def_property_ui_text(prop, "Runtime", "Property has been dynamically created at runtime");
1157
1158         prop = RNA_def_property(srna, "is_enum_flag", PROP_BOOLEAN, PROP_NONE);
1159         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1160         RNA_def_property_boolean_funcs(prop, "rna_Property_is_enum_flag_get", NULL);
1161         RNA_def_property_ui_text(prop, "Enum Flag", "True when multiple enums ");
1162 }
1163
1164 static void rna_def_function(BlenderRNA *brna)
1165 {
1166         StructRNA *srna;
1167         PropertyRNA *prop;
1168
1169         srna = RNA_def_struct(brna, "Function", NULL);
1170         RNA_def_struct_ui_text(srna, "Function Definition", "RNA function definition");
1171         RNA_def_struct_ui_icon(srna, ICON_RNA);
1172
1173         prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
1174         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1175         RNA_def_property_string_funcs(prop, "rna_Function_identifier_get", "rna_Function_identifier_length", NULL);
1176         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
1177         RNA_def_struct_name_property(srna, prop);
1178
1179         prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
1180         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1181         RNA_def_property_string_funcs(prop, "rna_Function_description_get", "rna_Function_description_length", NULL);
1182         RNA_def_property_ui_text(prop, "Description", "Description of the Function's purpose");
1183
1184         prop = RNA_def_property(srna, "parameters", PROP_COLLECTION, PROP_NONE);
1185         /*RNA_def_property_clear_flag(prop, PROP_EDITABLE);*/
1186         RNA_def_property_struct_type(prop, "Property");
1187         RNA_def_property_collection_funcs(prop, "rna_Function_parameters_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", NULL, NULL, NULL, NULL);
1188         RNA_def_property_ui_text(prop, "Parameters", "Parameters for the function");
1189
1190         prop = RNA_def_property(srna, "is_registered", PROP_BOOLEAN, PROP_NONE);
1191         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1192         RNA_def_property_boolean_funcs(prop, "rna_Function_registered_get", NULL);
1193         RNA_def_property_ui_text(prop, "Registered", "Function is registered as callback as part of type registration");
1194
1195         prop = RNA_def_property(srna, "is_registered_optional", PROP_BOOLEAN, PROP_NONE);
1196         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1197         RNA_def_property_boolean_funcs(prop, "rna_Function_registered_optional_get", NULL);
1198         RNA_def_property_ui_text(prop, "Registered Optionally", "Function is optionally registered as callback part of type registration");
1199
1200         prop = RNA_def_property(srna, "use_self", PROP_BOOLEAN, PROP_NONE);
1201         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1202         RNA_def_property_boolean_funcs(prop, "rna_Function_no_self_get", NULL);
1203         RNA_def_property_ui_text(prop, "No Self", "Function does not pass its self as an argument (becomes a class method in python)");
1204 }
1205
1206 static void rna_def_number_property(StructRNA *srna, PropertyType type)
1207 {
1208         PropertyRNA *prop;
1209
1210         prop = RNA_def_property(srna, "default", type, PROP_NONE);
1211         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1212         RNA_def_property_ui_text(prop, "Default", "Default value for this number");
1213
1214         switch (type) {
1215                 case PROP_BOOLEAN:
1216                         RNA_def_property_boolean_funcs(prop, "rna_BoolProperty_default_get", NULL);
1217                         break;
1218                 case PROP_INT:
1219                         RNA_def_property_int_funcs(prop, "rna_IntProperty_default_get", NULL, NULL);
1220                         break;
1221                 case PROP_FLOAT:
1222                         RNA_def_property_float_funcs(prop, "rna_FloatProperty_default_get", NULL, NULL);
1223                         break;
1224                 default:
1225                         break;
1226         }
1227
1228
1229         prop = RNA_def_property(srna, "default_array", type, PROP_NONE);
1230         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1231         RNA_def_property_array(prop, RNA_MAX_ARRAY_DIMENSION); /* no fixed default length, important its not 0 though */
1232         RNA_def_property_flag(prop, PROP_DYNAMIC);
1233         RNA_def_property_dynamic_array_funcs(prop, "rna_NumberProperty_default_array_get_length"); /* same for all types */
1234
1235         switch (type) {
1236                 case PROP_BOOLEAN:
1237                         RNA_def_property_boolean_funcs(prop, "rna_BoolProperty_default_array_get", NULL);
1238                         break;
1239                 case PROP_INT:
1240                         RNA_def_property_int_funcs(prop, "rna_IntProperty_default_array_get", NULL, NULL);
1241                         break;
1242                 case PROP_FLOAT:
1243                         RNA_def_property_float_funcs(prop, "rna_FloatProperty_default_array_get", NULL, NULL);
1244                         break;
1245                 default:
1246                         break;
1247         }
1248         RNA_def_property_ui_text(prop, "Default Array", "Default value for this array");
1249
1250
1251         prop = RNA_def_property(srna, "array_length", PROP_INT, PROP_UNSIGNED);
1252         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1253         RNA_def_property_int_funcs(prop, "rna_Property_array_length_get", NULL, NULL);
1254         RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited");
1255
1256         if (type == PROP_BOOLEAN)
1257                 return;
1258
1259         prop = RNA_def_property(srna, "hard_min", type, PROP_NONE);
1260         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1261         if (type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_min_get", NULL, NULL);
1262         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_min_get", NULL, NULL);
1263         RNA_def_property_ui_text(prop, "Hard Minimum", "Minimum value used by buttons");
1264
1265         prop = RNA_def_property(srna, "hard_max", type, PROP_NONE);
1266         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1267         if (type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_max_get", NULL, NULL);
1268         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_max_get", NULL, NULL);
1269         RNA_def_property_ui_text(prop, "Hard Maximum", "Maximum value used by buttons");
1270
1271         prop = RNA_def_property(srna, "soft_min", type, PROP_NONE);
1272         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1273         if (type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_min_get", NULL, NULL);
1274         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_min_get", NULL, NULL);
1275         RNA_def_property_ui_text(prop, "Soft Minimum", "Minimum value used by buttons");
1276
1277         prop = RNA_def_property(srna, "soft_max", type, PROP_NONE);
1278         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1279         if (type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_max_get", NULL, NULL);
1280         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_max_get", NULL, NULL);
1281         RNA_def_property_ui_text(prop, "Soft Maximum", "Maximum value used by buttons");
1282
1283         prop = RNA_def_property(srna, "step", type, PROP_UNSIGNED);
1284         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1285         if (type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_step_get", NULL, NULL);
1286         else RNA_def_property_float_funcs(prop, "rna_FloatProperty_step_get", NULL, NULL);
1287         RNA_def_property_ui_text(prop, "Step", "Step size used by number buttons, for floats 1/100th of the step size");
1288
1289         if (type == PROP_FLOAT) {
1290                 prop = RNA_def_property(srna, "precision", PROP_INT, PROP_UNSIGNED);
1291                 RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1292                 RNA_def_property_int_funcs(prop, "rna_FloatProperty_precision_get", NULL, NULL);
1293                 RNA_def_property_ui_text(prop, "Precision", "Number of digits after the dot used by buttons");
1294         }
1295 }
1296
1297 static void rna_def_string_property(StructRNA *srna)
1298 {
1299         PropertyRNA *prop;
1300
1301         prop = RNA_def_property(srna, "default", PROP_STRING, PROP_NONE);
1302         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1303         RNA_def_property_string_funcs(prop, "rna_StringProperty_default_get", "rna_StringProperty_default_length", NULL);
1304         RNA_def_property_ui_text(prop, "Default", "string default value");
1305
1306         prop = RNA_def_property(srna, "length_max", PROP_INT, PROP_UNSIGNED);
1307         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1308         RNA_def_property_int_funcs(prop, "rna_StringProperty_max_length_get", NULL, NULL);
1309         RNA_def_property_ui_text(prop, "Maximum Length", "Maximum length of the string, 0 means unlimited");
1310 }
1311
1312 static void rna_def_enum_property(BlenderRNA *brna, StructRNA *srna)
1313 {
1314         PropertyRNA *prop;
1315
1316         /* the itemf func is used instead, keep blender happy */
1317         static EnumPropertyItem default_dummy_items[] = {
1318                 {PROP_NONE, "DUMMY", 0, "Dummy", ""},
1319                 {0, NULL, 0, NULL, NULL}};
1320
1321         prop = RNA_def_property(srna, "default", PROP_ENUM, PROP_NONE);
1322         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1323         RNA_def_property_enum_items(prop, default_dummy_items);
1324         RNA_def_property_enum_funcs(prop, "rna_EnumProperty_default_get", NULL, "rna_EnumProperty_default_itemf");
1325         RNA_def_property_ui_text(prop, "Default", "Default value for this enum");
1326
1327         /* same 'default' but uses 'PROP_ENUM_FLAG' */
1328         prop = RNA_def_property(srna, "default_flag", PROP_ENUM, PROP_NONE);
1329         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1330         RNA_def_property_flag(prop, PROP_ENUM_FLAG);
1331         RNA_def_property_enum_items(prop, default_dummy_items);
1332         RNA_def_property_enum_funcs(prop, "rna_EnumProperty_default_get", NULL, "rna_EnumProperty_default_itemf");
1333         RNA_def_property_ui_text(prop, "Default", "Default value for this enum");
1334
1335         prop = RNA_def_property(srna, "enum_items", PROP_COLLECTION, PROP_NONE);
1336         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1337         RNA_def_property_struct_type(prop, "EnumPropertyItem");
1338         RNA_def_property_collection_funcs(prop, "rna_EnumProperty_items_begin", "rna_iterator_array_next", "rna_iterator_array_end", "rna_iterator_array_get", NULL, NULL, NULL, NULL);
1339         RNA_def_property_ui_text(prop, "Items", "Possible values for the property");
1340
1341         srna = RNA_def_struct(brna, "EnumPropertyItem", NULL);
1342         RNA_def_struct_ui_text(srna, "Enum Item Definition", "Definition of a choice in an RNA enum property");
1343         RNA_def_struct_ui_icon(srna, ICON_RNA);
1344
1345         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1346         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1347         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_name_get", "rna_EnumPropertyItem_name_length", NULL);
1348         RNA_def_property_ui_text(prop, "Name", "Human readable name");
1349
1350         prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
1351         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1352         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_description_get", "rna_EnumPropertyItem_description_length", NULL);
1353         RNA_def_property_ui_text(prop, "Description", "Description of the item's purpose");
1354
1355         prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
1356         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1357         RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_identifier_get", "rna_EnumPropertyItem_identifier_length", NULL);
1358         RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting");
1359         RNA_def_struct_name_property(srna, prop);
1360
1361         prop = RNA_def_property(srna, "value", PROP_INT, PROP_UNSIGNED);
1362         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1363         RNA_def_property_int_funcs(prop, "rna_EnumPropertyItem_value_get", NULL, NULL);
1364         RNA_def_property_ui_text(prop, "Value", "Value of the item");
1365 }
1366
1367 static void rna_def_pointer_property(StructRNA *srna, PropertyType type)
1368 {
1369         PropertyRNA *prop;
1370
1371         prop = RNA_def_property(srna, "fixed_type", PROP_POINTER, PROP_NONE);
1372         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1373         RNA_def_property_struct_type(prop, "Struct");
1374         if (type == PROP_POINTER)
1375                 RNA_def_property_pointer_funcs(prop, "rna_PointerProperty_fixed_type_get", NULL, NULL, NULL);
1376         else
1377                 RNA_def_property_pointer_funcs(prop, "rna_CollectionProperty_fixed_type_get", NULL, NULL, NULL);
1378         RNA_def_property_ui_text(prop, "Pointer Type", "Fixed pointer type, empty if variable type");
1379 }
1380
1381 void RNA_def_rna(BlenderRNA *brna)
1382 {
1383         StructRNA *srna;
1384         PropertyRNA *prop;
1385
1386         /* Struct*/
1387         rna_def_struct(brna);
1388
1389         /* Property */
1390         rna_def_property(brna);
1391
1392         /* BoolProperty */
1393         srna = RNA_def_struct(brna, "BoolProperty", "Property");
1394         RNA_def_struct_ui_text(srna, "Boolean Definition", "RNA boolean property definition");
1395         rna_def_number_property(srna, PROP_BOOLEAN);
1396
1397         /* IntProperty */
1398         srna = RNA_def_struct(brna, "IntProperty", "Property");
1399         RNA_def_struct_ui_text(srna, "Int Definition", "RNA integer number property definition");
1400         rna_def_number_property(srna, PROP_INT);
1401
1402         /* FloatProperty */
1403         srna = RNA_def_struct(brna, "FloatProperty", "Property");
1404         RNA_def_struct_ui_text(srna, "Float Definition", "RNA floating pointer number property definition");
1405         rna_def_number_property(srna, PROP_FLOAT);
1406
1407         /* StringProperty */
1408         srna = RNA_def_struct(brna, "StringProperty", "Property");
1409         RNA_def_struct_ui_text(srna, "String Definition", "RNA text string property definition");
1410         rna_def_string_property(srna);
1411
1412         /* EnumProperty */
1413         srna = RNA_def_struct(brna, "EnumProperty", "Property");
1414         RNA_def_struct_ui_text(srna, "Enum Definition", "RNA enumeration property definition, to choose from a number of predefined options");
1415         rna_def_enum_property(brna, srna);
1416
1417         /* PointerProperty */
1418         srna = RNA_def_struct(brna, "PointerProperty", "Property");
1419         RNA_def_struct_ui_text(srna, "Pointer Definition", "RNA pointer property to point to another RNA struct");
1420         rna_def_pointer_property(srna, PROP_POINTER);
1421
1422         /* CollectionProperty */
1423         srna = RNA_def_struct(brna, "CollectionProperty", "Property");
1424         RNA_def_struct_ui_text(srna, "Collection Definition", "RNA collection property to define lists, arrays and mappings");
1425         rna_def_pointer_property(srna, PROP_COLLECTION);
1426         
1427         /* Function */
1428         rna_def_function(brna);
1429
1430         /* Blender RNA */
1431         srna = RNA_def_struct(brna, "BlenderRNA", NULL);
1432         RNA_def_struct_ui_text(srna, "Blender RNA", "Blender RNA structure definitions");
1433         RNA_def_struct_ui_icon(srna, ICON_RNA);
1434
1435         prop = RNA_def_property(srna, "structs", PROP_COLLECTION, PROP_NONE);
1436         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1437         RNA_def_property_struct_type(prop, "Struct");
1438         RNA_def_property_collection_funcs(prop, "rna_BlenderRNA_structs_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get",
1439                 /* included for speed, can be removed */
1440 #if 0
1441                         0,0,0,0);
1442 #else
1443                         "rna_BlenderRNA_structs_length", "rna_BlenderRNA_structs_lookup_int", "rna_BlenderRNA_structs_lookup_string", NULL);
1444 #endif
1445
1446         RNA_def_property_ui_text(prop, "Structs", "");
1447 }
1448
1449 #endif
1450