Merge branch 'master' into blender2.8
[blender.git] / source / blender / makesrna / intern / rna_define.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_define.c
24  *  \ingroup RNA
25  */
26
27
28 #include <float.h>
29 #include <limits.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <stddef.h>
33 #include <string.h>
34 #include <ctype.h>
35
36 #include "BLI_utildefines.h"
37 #include "MEM_guardedalloc.h"
38
39 #include "DNA_genfile.h"
40 #include "DNA_sdna_types.h"
41
42 #include "BLI_listbase.h"
43 #include "BLI_ghash.h"
44
45 #include "BLT_translation.h"
46
47 #include "RNA_define.h"
48
49 #include "rna_internal.h"
50
51
52 #ifdef DEBUG
53 #  define ASSERT_SOFT_HARD_LIMITS \
54         if (softmin < hardmin || softmax > hardmax) { \
55                 fprintf(stderr, "Error with soft/hard limits: %s.%s\n", CONTAINER_RNA_ID(cont), identifier); \
56                 BLI_assert(!"invalid soft/hard limits"); \
57         } (void)0
58 #else
59 #  define  ASSERT_SOFT_HARD_LIMITS (void)0
60 #endif
61
62 /* Global used during defining */
63
64 BlenderDefRNA DefRNA = {NULL, {NULL, NULL}, {NULL, NULL}, NULL, 0, 0, 0, 1, 1};
65
66 /* Duplicated code since we can't link in blenkernel or blenlib */
67
68 /* pedantic check for final '.', note '...' are allowed though. */
69 #ifndef NDEBUG
70 #  define DESCR_CHECK(description, id1, id2)                                       \
71         if (description && (description)[0]) {                                         \
72                 int i = strlen(description);                                               \
73                 if (i > 3 && (description)[i - 1] == '.' && (description)[i - 3] != '.') { \
74                         fprintf(stderr, "%s: '%s' description from '%s' '%s' ends with a '.' !\n",       \
75                                 __func__, description, id1 ? id1 : "", id2 ? id2 : "");                     \
76                 }                                                                          \
77         } (void)0
78
79 #else
80 #  define DESCR_CHECK(description, id1, id2)
81 #endif
82
83 void rna_addtail(ListBase *listbase, void *vlink)
84 {
85         Link *link = vlink;
86
87         link->next = NULL;
88         link->prev = listbase->last;
89
90         if (listbase->last) ((Link *)listbase->last)->next = link;
91         if (listbase->first == NULL) listbase->first = link;
92         listbase->last = link;
93 }
94
95 static void rna_remlink(ListBase *listbase, void *vlink)
96 {
97         Link *link = vlink;
98
99         if (link->next) link->next->prev = link->prev;
100         if (link->prev) link->prev->next = link->next;
101
102         if (listbase->last == link) listbase->last = link->prev;
103         if (listbase->first == link) listbase->first = link->next;
104 }
105
106 PropertyDefRNA *rna_findlink(ListBase *listbase, const char *identifier)
107 {
108         Link *link;
109
110         for (link = listbase->first; link; link = link->next) {
111                 PropertyRNA *prop = ((PropertyDefRNA *)link)->prop;
112                 if (prop && (STREQ(prop->identifier, identifier))) {
113                         return (PropertyDefRNA *)link;
114                 }
115         }
116
117         return NULL;
118 }
119
120 void rna_freelinkN(ListBase *listbase, void *vlink)
121 {
122         rna_remlink(listbase, vlink);
123         MEM_freeN(vlink);
124 }
125
126 void rna_freelistN(ListBase *listbase)
127 {
128         Link *link, *next;
129         
130         for (link = listbase->first; link; link = next) {
131                 next = link->next;
132                 MEM_freeN(link);
133         }
134         
135         listbase->first = listbase->last = NULL;
136 }
137
138 static void rna_brna_structs_add(BlenderRNA *brna, StructRNA *srna)
139 {
140         rna_addtail(&brna->structs, srna);
141         brna->structs_len += 1;
142
143         /* This exception is only needed for pre-processing.
144          * otherwise we don't allow empty names. */
145         if ((srna->flag & STRUCT_PUBLIC_NAMESPACE) &&
146             (srna->identifier[0] != '\0'))
147         {
148                 BLI_ghash_insert(brna->structs_map, (void *)srna->identifier, srna);
149         }
150 }
151
152 #ifdef RNA_RUNTIME
153 static void rna_brna_structs_remove_and_free(BlenderRNA *brna, StructRNA *srna)
154 {
155         if ((srna->flag & STRUCT_PUBLIC_NAMESPACE) && brna->structs_map) {
156                 if (srna->identifier[0] != '\0') {
157                         BLI_ghash_remove(brna->structs_map, (void *)srna->identifier, NULL, NULL);
158                 }
159         }
160
161         RNA_def_struct_free_pointers(NULL, srna);
162
163         if (srna->flag & STRUCT_RUNTIME) {
164                 rna_freelinkN(&brna->structs, srna);
165         }
166         brna->structs_len -= 1;
167 }
168 #endif
169
170 StructDefRNA *rna_find_struct_def(StructRNA *srna)
171 {
172         StructDefRNA *dsrna;
173
174         if (!DefRNA.preprocess) {
175                 /* we should never get here */
176                 fprintf(stderr, "%s: only at preprocess time.\n", __func__);
177                 return NULL;
178         }
179
180         dsrna = DefRNA.structs.last;
181         for (; dsrna; dsrna = dsrna->cont.prev)
182                 if (dsrna->srna == srna)
183                         return dsrna;
184
185         return NULL;
186 }
187
188 PropertyDefRNA *rna_find_struct_property_def(StructRNA *srna, PropertyRNA *prop)
189 {
190         StructDefRNA *dsrna;
191         PropertyDefRNA *dprop;
192
193         if (!DefRNA.preprocess) {
194                 /* we should never get here */
195                 fprintf(stderr, "%s: only at preprocess time.\n", __func__);
196                 return NULL;
197         }
198
199         dsrna = rna_find_struct_def(srna);
200         dprop = dsrna->cont.properties.last;
201         for (; dprop; dprop = dprop->prev)
202                 if (dprop->prop == prop)
203                         return dprop;
204
205         dsrna = DefRNA.structs.last;
206         for (; dsrna; dsrna = dsrna->cont.prev) {
207                 dprop = dsrna->cont.properties.last;
208                 for (; dprop; dprop = dprop->prev)
209                         if (dprop->prop == prop)
210                                 return dprop;
211         }
212
213         return NULL;
214 }
215
216 #if 0
217 static PropertyDefRNA *rna_find_property_def(PropertyRNA *prop)
218 {
219         PropertyDefRNA *dprop;
220
221         if (!DefRNA.preprocess) {
222                 /* we should never get here */
223                 fprintf(stderr, "%s: only at preprocess time.\n", __func__);
224                 return NULL;
225         }
226
227         dprop = rna_find_struct_property_def(DefRNA.laststruct, prop);
228         if (dprop)
229                 return dprop;
230
231         dprop = rna_find_parameter_def(prop);
232         if (dprop)
233                 return dprop;
234
235         return NULL;
236 }
237 #endif
238
239 FunctionDefRNA *rna_find_function_def(FunctionRNA *func)
240 {
241         StructDefRNA *dsrna;
242         FunctionDefRNA *dfunc;
243
244         if (!DefRNA.preprocess) {
245                 /* we should never get here */
246                 fprintf(stderr, "%s: only at preprocess time.\n", __func__);
247                 return NULL;
248         }
249
250         dsrna = rna_find_struct_def(DefRNA.laststruct);
251         dfunc = dsrna->functions.last;
252         for (; dfunc; dfunc = dfunc->cont.prev)
253                 if (dfunc->func == func)
254                         return dfunc;
255
256         dsrna = DefRNA.structs.last;
257         for (; dsrna; dsrna = dsrna->cont.prev) {
258                 dfunc = dsrna->functions.last;
259                 for (; dfunc; dfunc = dfunc->cont.prev)
260                         if (dfunc->func == func)
261                                 return dfunc;
262         }
263
264         return NULL;
265 }
266
267 PropertyDefRNA *rna_find_parameter_def(PropertyRNA *parm)
268 {
269         StructDefRNA *dsrna;
270         FunctionDefRNA *dfunc;
271         PropertyDefRNA *dparm;
272
273         if (!DefRNA.preprocess) {
274                 /* we should never get here */
275                 fprintf(stderr, "%s: only at preprocess time.\n", __func__);
276                 return NULL;
277         }
278
279         dsrna = rna_find_struct_def(DefRNA.laststruct);
280         dfunc = dsrna->functions.last;
281         for (; dfunc; dfunc = dfunc->cont.prev) {
282                 dparm = dfunc->cont.properties.last;
283                 for (; dparm; dparm = dparm->prev)
284                         if (dparm->prop == parm)
285                                 return dparm;
286         }
287
288         dsrna = DefRNA.structs.last;
289         for (; dsrna; dsrna = dsrna->cont.prev) {
290                 dfunc = dsrna->functions.last;
291                 for (; dfunc; dfunc = dfunc->cont.prev) {
292                         dparm = dfunc->cont.properties.last;
293                         for (; dparm; dparm = dparm->prev)
294                                 if (dparm->prop == parm)
295                                         return dparm;
296                 }
297         }
298
299         return NULL;
300 }
301
302 static ContainerDefRNA *rna_find_container_def(ContainerRNA *cont)
303 {
304         StructDefRNA *ds;
305         FunctionDefRNA *dfunc;
306
307         if (!DefRNA.preprocess) {
308                 /* we should never get here */
309                 fprintf(stderr, "%s: only at preprocess time.\n", __func__);
310                 return NULL;
311         }
312
313         ds = rna_find_struct_def((StructRNA *)cont);
314         if (ds)
315                 return &ds->cont;
316
317         dfunc = rna_find_function_def((FunctionRNA *)cont);
318         if (dfunc)
319                 return &dfunc->cont;
320
321         return NULL;
322 }
323
324 /* DNA utility function for looking up members */
325
326 typedef struct DNAStructMember {
327         const char *type;
328         const char *name;
329         int arraylength;
330         int pointerlevel;
331 } DNAStructMember;
332
333 static int rna_member_cmp(const char *name, const char *oname)
334 {
335         int a = 0;
336         
337         /* compare without pointer or array part */
338         while (name[0] == '*')
339                 name++;
340         while (oname[0] == '*')
341                 oname++;
342         
343         while (1) {
344                 if (name[a] == '[' && oname[a] == 0) return 1;
345                 if (name[a] == '[' && oname[a] == '[') return 1;
346                 if (name[a] == 0) break;
347                 if (name[a] != oname[a]) return 0;
348                 a++;
349         }
350         if (name[a] == 0 && oname[a] == '.') return 2;
351         if (name[a] == 0 && oname[a] == '-' && oname[a + 1] == '>') return 3;
352
353         return (name[a] == oname[a]);
354 }
355
356 static int rna_find_sdna_member(SDNA *sdna, const char *structname, const char *membername, DNAStructMember *smember)
357 {
358         const char *dnaname;
359         const short *sp;
360         int a, b, structnr, totmember, cmp;
361
362         structnr = DNA_struct_find_nr(sdna, structname);
363         if (structnr == -1)
364                 return 0;
365
366         sp = sdna->structs[structnr];
367         totmember = sp[1];
368         sp += 2;
369
370         for (a = 0; a < totmember; a++, sp += 2) {
371                 dnaname = sdna->names[sp[1]];
372
373                 cmp = rna_member_cmp(dnaname, membername);
374
375                 if (cmp == 1) {
376                         smember->type = sdna->types[sp[0]];
377                         smember->name = dnaname;
378
379                         if (strstr(membername, "["))
380                                 smember->arraylength = 0;
381                         else
382                                 smember->arraylength = DNA_elem_array_size(smember->name);
383
384                         smember->pointerlevel = 0;
385                         for (b = 0; dnaname[b] == '*'; b++)
386                                 smember->pointerlevel++;
387
388                         return 1;
389                 }
390                 else if (cmp == 2) {
391                         smember->type = "";
392                         smember->name = dnaname;
393                         smember->pointerlevel = 0;
394                         smember->arraylength = 0;
395
396                         membername = strstr(membername, ".") + strlen(".");
397                         rna_find_sdna_member(sdna, sdna->types[sp[0]], membername, smember);
398
399                         return 1;
400                 }
401                 else if (cmp == 3) {
402                         smember->type = "";
403                         smember->name = dnaname;
404                         smember->pointerlevel = 0;
405                         smember->arraylength = 0;
406
407                         membername = strstr(membername, "->") + strlen("->");
408                         rna_find_sdna_member(sdna, sdna->types[sp[0]], membername, smember);
409
410                         return 1;
411                 }
412         }
413
414         return 0;
415 }
416
417 static int rna_validate_identifier(const char *identifier, char *error, bool property)
418 {
419         int a = 0;
420         
421         /* list is from...
422          * ", ".join(['"%s"' % kw for kw in  __import__("keyword").kwlist if kw not in {"False", "None", "True"}])
423          */
424         static const char *kwlist[] = {
425                 /* "False", "None", "True", */
426                 "and", "as", "assert", "break",
427                 "class", "continue", "def", "del", "elif", "else", "except",
428                 "finally", "for", "from", "global", "if", "import", "in",
429                 "is", "lambda", "nonlocal", "not", "or", "pass", "raise",
430                 "return", "try", "while", "with", "yield", NULL
431         };
432         
433         
434         if (!isalpha(identifier[0])) {
435                 strcpy(error, "first character failed isalpha() check");
436                 return 0;
437         }
438         
439         for (a = 0; identifier[a]; a++) {
440                 if (DefRNA.preprocess && property) {
441                         if (isalpha(identifier[a]) && isupper(identifier[a])) {
442                                 strcpy(error, "property names must contain lower case characters only");
443                                 return 0;
444                         }
445                 }
446                 
447                 if (identifier[a] == '_') {
448                         continue;
449                 }
450
451                 if (identifier[a] == ' ') {
452                         strcpy(error, "spaces are not okay in identifier names");
453                         return 0;
454                 }
455
456                 if (isalnum(identifier[a]) == 0) {
457                         strcpy(error, "one of the characters failed an isalnum() check and is not an underscore");
458                         return 0;
459                 }
460         }
461         
462         for (a = 0; kwlist[a]; a++) {
463                 if (STREQ(identifier, kwlist[a])) {
464                         strcpy(error, "this keyword is reserved by python");
465                         return 0;
466                 }
467         }
468
469         if (property) {
470                 static const char *kwlist_prop[] = {
471                         /* not keywords but reserved all the same because py uses */
472                         "keys", "values", "items", "get",
473                         NULL
474                 };
475
476                 for (a = 0; kwlist_prop[a]; a++) {
477                         if (STREQ(identifier, kwlist_prop[a])) {
478                                 strcpy(error, "this keyword is reserved by python");
479                                 return 0;
480                         }
481                 }
482         }
483         
484         return 1;
485 }
486
487 void RNA_identifier_sanitize(char *identifier, int property)
488 {
489         int a = 0;
490         
491         /*  list from http://docs.python.org/py3k/reference/lexical_analysis.html#keywords */
492         static const char *kwlist[] = {
493                 /* "False", "None", "True", */
494                 "and", "as", "assert", "break",
495                 "class", "continue", "def", "del", "elif", "else", "except",
496                 "finally", "for", "from", "global", "if", "import", "in",
497                 "is", "lambda", "nonlocal", "not", "or", "pass", "raise",
498                 "return", "try", "while", "with", "yield", NULL
499         };
500         
501         
502         if (!isalpha(identifier[0])) {
503                 /* first character failed isalpha() check */
504                 identifier[0] = '_';
505         }
506         
507         for (a = 0; identifier[a]; a++) {
508                 if (DefRNA.preprocess && property) {
509                         if (isalpha(identifier[a]) && isupper(identifier[a])) {
510                                 /* property names must contain lower case characters only */
511                                 identifier[a] = tolower(identifier[a]);
512                         }
513                 }
514                 
515                 if (identifier[a] == '_') {
516                         continue;
517                 }
518
519                 if (identifier[a] == ' ') {
520                         /* spaces are not okay in identifier names */
521                         identifier[a] = '_';
522                 }
523
524                 if (isalnum(identifier[a]) == 0) {
525                         /* one of the characters failed an isalnum() check and is not an underscore */
526                         identifier[a] = '_';
527                 }
528         }
529         
530         for (a = 0; kwlist[a]; a++) {
531                 if (STREQ(identifier, kwlist[a])) {
532                         /* this keyword is reserved by python.
533                          * just replace the last character by '_' to keep it readable.
534                          */
535                         identifier[strlen(identifier) - 1] = '_';
536                         break;
537                 }
538         }
539
540         if (property) {
541                 static const char *kwlist_prop[] = {
542                         /* not keywords but reserved all the same because py uses */
543                         "keys", "values", "items", "get",
544                         NULL
545                 };
546
547                 for (a = 0; kwlist_prop[a]; a++) {
548                         if (STREQ(identifier, kwlist_prop[a])) {
549                                 /* this keyword is reserved by python.
550                                  * just replace the last character by '_' to keep it readable.
551                                  */
552                                 identifier[strlen(identifier) - 1] = '_';
553                                 break;
554                         }
555                 }
556         }
557 }
558
559 /* Blender Data Definition */
560
561 BlenderRNA *RNA_create(void)
562 {
563         BlenderRNA *brna;
564
565         brna = MEM_callocN(sizeof(BlenderRNA), "BlenderRNA");
566         const char *error_message = NULL;
567
568         BLI_listbase_clear(&DefRNA.structs);
569         brna->structs_map = BLI_ghash_str_new_ex(__func__, 2048);
570
571         DefRNA.error = 0;
572         DefRNA.preprocess = 1;
573
574         DefRNA.sdna = DNA_sdna_from_data(DNAstr, DNAlen, false, false, &error_message);
575         if (DefRNA.sdna == NULL) {
576                 fprintf(stderr, "Error decoding SDNA: %s\n", error_message);
577                 DefRNA.error = 1;
578         }
579
580         return brna;
581 }
582
583 void RNA_define_free(BlenderRNA *UNUSED(brna))
584 {
585         StructDefRNA *ds;
586         FunctionDefRNA *dfunc;
587         AllocDefRNA *alloc;
588
589         for (alloc = DefRNA.allocs.first; alloc; alloc = alloc->next)
590                 MEM_freeN(alloc->mem);
591         rna_freelistN(&DefRNA.allocs);
592
593         for (ds = DefRNA.structs.first; ds; ds = ds->cont.next) {
594                 for (dfunc = ds->functions.first; dfunc; dfunc = dfunc->cont.next)
595                         rna_freelistN(&dfunc->cont.properties);
596
597                 rna_freelistN(&ds->cont.properties);
598                 rna_freelistN(&ds->functions);
599         }
600
601         rna_freelistN(&DefRNA.structs);
602
603         if (DefRNA.sdna) {
604                 DNA_sdna_free(DefRNA.sdna);
605                 DefRNA.sdna = NULL;
606         }
607
608         DefRNA.error = 0;
609 }
610
611 void RNA_define_verify_sdna(bool verify)
612 {
613         DefRNA.verify = verify;
614 }
615
616 #ifndef RNA_RUNTIME
617 void RNA_define_animate_sdna(bool animate)
618 {
619         DefRNA.animate = animate;
620 }
621 #endif
622
623 void RNA_struct_free_extension(StructRNA *srna, ExtensionRNA *ext)
624 {
625 #ifdef RNA_RUNTIME
626         ext->free(ext->data);                     /* decref's the PyObject that the srna owns */
627         RNA_struct_blender_type_set(srna, NULL);  /* this gets accessed again - XXX fixme */
628         RNA_struct_py_type_set(srna, NULL);       /* NULL the srna's value so RNA_struct_free wont complain of a leak */
629 #else
630         (void)srna;
631         (void)ext;
632 #endif
633 }
634
635 void RNA_struct_free(BlenderRNA *brna, StructRNA *srna)
636 {
637 #ifdef RNA_RUNTIME
638         FunctionRNA *func, *nextfunc;
639         PropertyRNA *prop, *nextprop;
640         PropertyRNA *parm, *nextparm;
641
642 #if 0
643         if (srna->flag & STRUCT_RUNTIME) {
644                 if (RNA_struct_py_type_get(srna)) {
645                         fprintf(stderr, "%s '%s' freed while holding a python reference\n", __func__, srna->identifier);
646                 }
647         }
648 #endif
649
650         for (prop = srna->cont.properties.first; prop; prop = nextprop) {
651                 nextprop = prop->next;
652
653                 RNA_def_property_free_pointers(prop);
654
655                 if (prop->flag_internal & PROP_INTERN_RUNTIME)
656                         rna_freelinkN(&srna->cont.properties, prop);
657         }
658
659         for (func = srna->functions.first; func; func = nextfunc) {
660                 nextfunc = func->cont.next;
661
662                 for (parm = func->cont.properties.first; parm; parm = nextparm) {
663                         nextparm = parm->next;
664
665                         RNA_def_property_free_pointers(parm);
666
667                         if (parm->flag_internal & PROP_INTERN_RUNTIME)
668                                 rna_freelinkN(&func->cont.properties, parm);
669                 }
670
671                 RNA_def_func_free_pointers(func);
672
673                 if (func->flag & FUNC_RUNTIME)
674                         rna_freelinkN(&srna->functions, func);
675         }
676
677
678         rna_brna_structs_remove_and_free(brna, srna);
679 #else
680         UNUSED_VARS(brna, srna);
681 #endif
682 }
683
684 void RNA_free(BlenderRNA *brna)
685 {
686         StructRNA *srna, *nextsrna;
687         FunctionRNA *func;
688
689         BLI_ghash_free(brna->structs_map, NULL, NULL);
690         brna->structs_map = NULL;
691
692         if (DefRNA.preprocess) {
693                 RNA_define_free(brna);
694
695                 for (srna = brna->structs.first; srna; srna = srna->cont.next) {
696                         for (func = srna->functions.first; func; func = func->cont.next)
697                                 rna_freelistN(&func->cont.properties);
698
699                         rna_freelistN(&srna->cont.properties);
700                         rna_freelistN(&srna->functions);
701                 }
702
703                 rna_freelistN(&brna->structs);
704                 
705                 MEM_freeN(brna);
706         }
707         else {
708                 for (srna = brna->structs.first; srna; srna = nextsrna) {
709                         nextsrna = srna->cont.next;
710                         RNA_struct_free(brna, srna);
711                 }
712         }
713 }
714
715 static size_t rna_property_type_sizeof(PropertyType type)
716 {
717         switch (type) {
718                 case PROP_BOOLEAN: return sizeof(BoolPropertyRNA);
719                 case PROP_INT: return sizeof(IntPropertyRNA);
720                 case PROP_FLOAT: return sizeof(FloatPropertyRNA);
721                 case PROP_STRING: return sizeof(StringPropertyRNA);
722                 case PROP_ENUM: return sizeof(EnumPropertyRNA);
723                 case PROP_POINTER: return sizeof(PointerPropertyRNA);
724                 case PROP_COLLECTION: return sizeof(CollectionPropertyRNA);
725                 default: return 0;
726         }
727 }
728
729 static StructDefRNA *rna_find_def_struct(StructRNA *srna)
730 {
731         StructDefRNA *ds;
732
733         for (ds = DefRNA.structs.first; ds; ds = ds->cont.next)
734                 if (ds->srna == srna)
735                         return ds;
736
737         return NULL;
738 }
739
740 /* Struct Definition */
741 StructRNA *RNA_def_struct_ptr(BlenderRNA *brna, const char *identifier, StructRNA *srnafrom)
742 {
743         StructRNA *srna;
744         StructDefRNA *ds = NULL, *dsfrom = NULL;
745         PropertyRNA *prop;
746
747         if (DefRNA.preprocess) {
748                 char error[512];
749
750                 if (rna_validate_identifier(identifier, error, false) == 0) {
751                         fprintf(stderr, "%s: struct identifier \"%s\" error - %s\n", __func__, identifier, error);
752                         DefRNA.error = 1;
753                 }
754         }
755
756         srna = MEM_callocN(sizeof(StructRNA), "StructRNA");
757         DefRNA.laststruct = srna;
758
759         if (srnafrom) {
760                 /* copy from struct to derive stuff, a bit clumsy since we can't
761                  * use MEM_dupallocN, data structs may not be alloced but builtin */
762                 memcpy(srna, srnafrom, sizeof(StructRNA));
763                 srna->cont.prophash = NULL;
764                 BLI_listbase_clear(&srna->cont.properties);
765                 BLI_listbase_clear(&srna->functions);
766                 srna->py_type = NULL;
767
768                 srna->base = srnafrom;
769
770                 if (DefRNA.preprocess) {
771                         dsfrom = rna_find_def_struct(srnafrom);
772                 }
773                 else {
774                         if (srnafrom->flag & STRUCT_PUBLIC_NAMESPACE_INHERIT) {
775                                 srna->flag |= STRUCT_PUBLIC_NAMESPACE | STRUCT_PUBLIC_NAMESPACE_INHERIT;
776                         }
777                         else {
778                                 srna->flag &= ~(STRUCT_PUBLIC_NAMESPACE | STRUCT_PUBLIC_NAMESPACE_INHERIT);
779                         }
780                 }
781         }
782
783         srna->identifier = identifier;
784         srna->name = identifier; /* may be overwritten later RNA_def_struct_ui_text */
785         srna->description = "";
786         /* may be overwritten later RNA_def_struct_translation_context */
787         srna->translation_context = BLT_I18NCONTEXT_DEFAULT_BPYRNA;
788         srna->flag |= STRUCT_UNDO;
789         if (!srnafrom)
790                 srna->icon = ICON_DOT;
791
792         if (DefRNA.preprocess) {
793                 srna->flag |= STRUCT_PUBLIC_NAMESPACE;
794         }
795
796         rna_brna_structs_add(brna, srna);
797
798         if (DefRNA.preprocess) {
799                 ds = MEM_callocN(sizeof(StructDefRNA), "StructDefRNA");
800                 ds->srna = srna;
801                 rna_addtail(&DefRNA.structs, ds);
802
803                 if (dsfrom)
804                         ds->dnafromname = dsfrom->dnaname;
805         }
806
807         /* in preprocess, try to find sdna */
808         if (DefRNA.preprocess)
809                 RNA_def_struct_sdna(srna, srna->identifier);
810         else
811                 srna->flag |= STRUCT_RUNTIME;
812
813         if (srnafrom) {
814                 srna->nameproperty = srnafrom->nameproperty;
815                 srna->iteratorproperty = srnafrom->iteratorproperty;
816         }
817         else {
818                 /* define some builtin properties */
819                 prop = RNA_def_property(&srna->cont, "rna_properties", PROP_COLLECTION, PROP_NONE);
820                 prop->flag_internal |= PROP_INTERN_BUILTIN;
821                 RNA_def_property_ui_text(prop, "Properties", "RNA property collection");
822
823                 if (DefRNA.preprocess) {
824                         RNA_def_property_struct_type(prop, "Property");
825                         RNA_def_property_collection_funcs(prop, "rna_builtin_properties_begin", "rna_builtin_properties_next",
826                                                           "rna_iterator_listbase_end", "rna_builtin_properties_get", NULL, NULL,
827                                                           "rna_builtin_properties_lookup_string", NULL);
828                 }
829                 else {
830 #ifdef RNA_RUNTIME
831                         CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)prop;
832                         cprop->begin = rna_builtin_properties_begin;
833                         cprop->next = rna_builtin_properties_next;
834                         cprop->get = rna_builtin_properties_get;
835                         cprop->item_type = &RNA_Property;
836 #endif
837                 }
838
839                 prop = RNA_def_property(&srna->cont, "rna_type", PROP_POINTER, PROP_NONE);
840                 RNA_def_property_flag(prop, PROP_HIDDEN);
841                 RNA_def_property_ui_text(prop, "RNA", "RNA type definition");
842
843                 if (DefRNA.preprocess) {
844                         RNA_def_property_struct_type(prop, "Struct");
845                         RNA_def_property_pointer_funcs(prop, "rna_builtin_type_get", NULL, NULL, NULL);
846                 }
847                 else {
848 #ifdef RNA_RUNTIME
849                         PointerPropertyRNA *pprop = (PointerPropertyRNA *)prop;
850                         pprop->get = rna_builtin_type_get;
851                         pprop->type = &RNA_Struct;
852 #endif
853                 }
854         }
855
856         return srna;
857 }
858
859 StructRNA *RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *from)
860 {
861         StructRNA *srnafrom = NULL;
862
863         /* only use RNA_def_struct() while pre-processing, otherwise use RNA_def_struct_ptr() */
864         BLI_assert(DefRNA.preprocess);
865
866         if (from) {
867                 /* find struct to derive from */
868                 /* Inline RNA_struct_find(...) because it wont link from here. */
869                 srnafrom = BLI_ghash_lookup(brna->structs_map, from);
870                 if (!srnafrom) {
871                         fprintf(stderr, "%s: struct %s not found to define %s.\n", __func__, from, identifier);
872                         DefRNA.error = 1;
873                 }
874         }
875
876         return RNA_def_struct_ptr(brna, identifier, srnafrom);
877 }
878
879 void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
880 {
881         StructDefRNA *ds;
882
883         if (!DefRNA.preprocess) {
884                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
885                 return;
886         }
887
888         ds = rna_find_def_struct(srna);
889
890         /* there are far too many structs which initialize without valid DNA struct names,
891          * this can't be checked without adding an option to disable (tested this and it means changes all over - Campbell) */
892 #if 0
893         if (DNA_struct_find_nr(DefRNA.sdna, structname) == -1) {
894                 if (!DefRNA.silent) {
895                         fprintf(stderr, "%s: %s not found.\n", __func__, structname);
896                         DefRNA.error = 1;
897                 }
898                 return;
899         }
900 #endif
901
902         ds->dnaname = structname;
903 }
904
905 void RNA_def_struct_sdna_from(StructRNA *srna, const char *structname, const char *propname)
906 {
907         StructDefRNA *ds;
908
909         if (!DefRNA.preprocess) {
910                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
911                 return;
912         }
913
914         ds = rna_find_def_struct(srna);
915
916         if (!ds->dnaname) {
917                 fprintf(stderr, "%s: %s base struct must know DNA already.\n", __func__, structname);
918                 return;
919         }
920
921         if (DNA_struct_find_nr(DefRNA.sdna, structname) == -1) {
922                 if (!DefRNA.silent) {
923                         fprintf(stderr, "%s: %s not found.\n", __func__, structname);
924                         DefRNA.error = 1;
925                 }
926                 return;
927         }
928
929         ds->dnafromprop = propname;
930         ds->dnaname = structname;
931 }
932
933 void RNA_def_struct_name_property(struct StructRNA *srna, struct PropertyRNA *prop)
934 {
935         if (prop->type != PROP_STRING) {
936                 fprintf(stderr, "%s: \"%s.%s\", must be a string property.\n", __func__, srna->identifier, prop->identifier);
937                 DefRNA.error = 1;
938         }
939         else
940                 srna->nameproperty = prop;
941 }
942
943 void RNA_def_struct_nested(BlenderRNA *brna, StructRNA *srna, const char *structname)
944 {
945         StructRNA *srnafrom;
946
947         /* find struct to derive from */
948         srnafrom = BLI_ghash_lookup(brna->structs_map, structname);
949         if (!srnafrom) {
950                 fprintf(stderr, "%s: struct %s not found for %s.\n", __func__, structname, srna->identifier);
951                 DefRNA.error = 1;
952         }
953
954         srna->nested = srnafrom;
955 }
956
957 void RNA_def_struct_flag(StructRNA *srna, int flag)
958 {
959         srna->flag |= flag;
960 }
961
962 void RNA_def_struct_clear_flag(StructRNA *srna, int flag)
963 {
964         srna->flag &= ~flag;
965 }
966
967 void RNA_def_struct_refine_func(StructRNA *srna, const char *refine)
968 {
969         if (!DefRNA.preprocess) {
970                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
971                 return;
972         }
973
974         if (refine) srna->refine = (StructRefineFunc)refine;
975 }
976
977 void RNA_def_struct_idprops_func(StructRNA *srna, const char *idproperties)
978 {
979         if (!DefRNA.preprocess) {
980                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
981                 return;
982         }
983
984         if (idproperties) srna->idproperties = (IDPropertiesFunc)idproperties;
985 }
986
987 void RNA_def_struct_register_funcs(StructRNA *srna, const char *reg, const char *unreg, const char *instance)
988 {
989         if (!DefRNA.preprocess) {
990                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
991                 return;
992         }
993
994         if (reg) srna->reg = (StructRegisterFunc)reg;
995         if (unreg) srna->unreg = (StructUnregisterFunc)unreg;
996         if (instance) srna->instance = (StructInstanceFunc)instance;
997 }
998
999 void RNA_def_struct_path_func(StructRNA *srna, const char *path)
1000 {
1001         if (!DefRNA.preprocess) {
1002                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1003                 return;
1004         }
1005
1006         if (path) srna->path = (StructPathFunc)path;
1007 }
1008
1009 void RNA_def_struct_identifier(BlenderRNA *brna, StructRNA *srna, const char *identifier)
1010 {
1011         if (DefRNA.preprocess) {
1012                 fprintf(stderr, "%s: only at runtime.\n", __func__);
1013                 return;
1014         }
1015
1016         /* Operator registration may set twice, see: operator_properties_init */
1017         if (srna->flag & STRUCT_PUBLIC_NAMESPACE) {
1018                 if (identifier != srna->identifier) {
1019                         if (srna->identifier[0] != '\0') {
1020                                 BLI_ghash_remove(brna->structs_map, (void *)srna->identifier, NULL, NULL);
1021                         }
1022                         if (identifier[0] != '\0') {
1023                                 BLI_ghash_insert(brna->structs_map, (void *)identifier, srna);
1024                         }
1025                 }
1026         }
1027
1028         srna->identifier = identifier;
1029 }
1030
1031 /**
1032  * Only used in one case when we name the struct for the purpose of useful error messages.
1033  */
1034 void RNA_def_struct_identifier_no_struct_map(StructRNA *srna, const char *identifier)
1035 {
1036         if (DefRNA.preprocess) {
1037                 fprintf(stderr, "%s: only at runtime.\n", __func__);
1038                 return;
1039         }
1040
1041         srna->identifier = identifier;
1042 }
1043
1044 void RNA_def_struct_ui_text(StructRNA *srna, const char *name, const char *description)
1045 {
1046         DESCR_CHECK(description, srna->identifier, NULL);
1047
1048         srna->name = name;
1049         srna->description = description;
1050 }
1051
1052 void RNA_def_struct_ui_icon(StructRNA *srna, int icon)
1053 {
1054         srna->icon = icon;
1055 }
1056
1057 void RNA_def_struct_translation_context(StructRNA *srna, const char *context)
1058 {
1059         srna->translation_context = context ? context : BLT_I18NCONTEXT_DEFAULT_BPYRNA;
1060 }
1061
1062 /* Property Definition */
1063
1064 PropertyRNA *RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier, int type, int subtype)
1065 {
1066         /*StructRNA *srna = DefRNA.laststruct;*/ /* invalid for python defined props */
1067         ContainerRNA *cont = cont_;
1068         ContainerDefRNA *dcont;
1069         PropertyDefRNA *dprop = NULL;
1070         PropertyRNA *prop;
1071
1072         if (DefRNA.preprocess) {
1073                 char error[512];
1074                 
1075                 if (rna_validate_identifier(identifier, error, true) == 0) {
1076                         fprintf(stderr, "%s: property identifier \"%s.%s\" - %s\n", __func__,
1077                                 CONTAINER_RNA_ID(cont), identifier, error);
1078                         DefRNA.error = 1;
1079                 }
1080                 
1081                 dcont = rna_find_container_def(cont);
1082
1083                 /* XXX - toto, detect supertype collisions */
1084                 if (rna_findlink(&dcont->properties, identifier)) {
1085                         fprintf(stderr, "%s: duplicate identifier \"%s.%s\"\n", __func__, CONTAINER_RNA_ID(cont), identifier);
1086                         DefRNA.error = 1;
1087                 }
1088
1089                 dprop = MEM_callocN(sizeof(PropertyDefRNA), "PropertyDefRNA");
1090                 rna_addtail(&dcont->properties, dprop);
1091         }
1092         else {
1093 #ifdef DEBUG
1094                 char error[512];
1095                 if (rna_validate_identifier(identifier, error, true) == 0) {
1096                         fprintf(stderr, "%s: runtime property identifier \"%s.%s\" - %s\n", __func__,
1097                                 CONTAINER_RNA_ID(cont), identifier, error);
1098                         DefRNA.error = 1;
1099                 }
1100 #endif
1101         }
1102
1103         prop = MEM_callocN(rna_property_type_sizeof(type), "PropertyRNA");
1104
1105         switch (type) {
1106                 case PROP_BOOLEAN:
1107                         if (DefRNA.preprocess) {
1108                                 if ((subtype & ~(PROP_LAYER_MEMBER)) != PROP_NONE) {
1109                                         fprintf(stderr, "%s: subtype does not apply to 'PROP_BOOLEAN' \"%s.%s\"\n", __func__,
1110                                                 CONTAINER_RNA_ID(cont), identifier);
1111                                         DefRNA.error = 1;
1112                                 }
1113                         }
1114                         break;
1115                 case PROP_INT:
1116                 {
1117                         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
1118
1119 #ifndef RNA_RUNTIME
1120                         if (subtype == PROP_DISTANCE) {
1121                                 fprintf(stderr, "%s: subtype does not apply to 'PROP_INT' \"%s.%s\"\n", __func__,
1122                                         CONTAINER_RNA_ID(cont), identifier);
1123                                 DefRNA.error = 1;
1124                         }
1125 #endif
1126
1127                         iprop->hardmin = (subtype == PROP_UNSIGNED) ? 0 : INT_MIN;
1128                         iprop->hardmax = INT_MAX;
1129
1130                         iprop->softmin = (subtype == PROP_UNSIGNED) ? 0 : -10000; /* rather arbitrary .. */
1131                         iprop->softmax = 10000;
1132                         iprop->step = 1;
1133                         break;
1134                 }
1135                 case PROP_FLOAT:
1136                 {
1137                         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
1138
1139                         fprop->hardmin = (subtype == PROP_UNSIGNED) ? 0.0f : -FLT_MAX;
1140                         fprop->hardmax = FLT_MAX;
1141
1142                         if (ELEM(subtype, PROP_COLOR, PROP_COLOR_GAMMA)) {
1143                                 fprop->softmin = fprop->hardmin = 0.0f;
1144                                 fprop->softmax = 1.0f;
1145                         }
1146                         else if (subtype == PROP_FACTOR) {
1147                                 fprop->softmin = fprop->hardmin = 0.0f;
1148                                 fprop->softmax = fprop->hardmax = 1.0f;
1149                         }
1150                         else {
1151                                 fprop->softmin = (subtype == PROP_UNSIGNED) ? 0.0f : -10000.0f; /* rather arbitrary .. */
1152                                 fprop->softmax = 10000.0f;
1153                         }
1154                         fprop->step = 10;
1155                         fprop->precision = 3;
1156                         break;
1157                 }
1158                 case PROP_STRING:
1159                 {
1160                         StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
1161
1162                         sprop->defaultvalue = "";
1163                         break;
1164                 }
1165                 case PROP_POINTER:
1166                         prop->flag |= PROP_THICK_WRAP;  /* needed for default behavior when PARM_RNAPTR is set */
1167                         break;
1168                 case PROP_ENUM:
1169                 case PROP_COLLECTION:
1170                         break;
1171                 default:
1172                         fprintf(stderr, "%s: \"%s.%s\", invalid property type.\n", __func__, CONTAINER_RNA_ID(cont), identifier);
1173                         DefRNA.error = 1;
1174                         return NULL;
1175         }
1176
1177         if (DefRNA.preprocess) {
1178                 dprop->cont = cont;
1179                 dprop->prop = prop;
1180         }
1181
1182         prop->magic = RNA_MAGIC;
1183         prop->identifier = identifier;
1184         prop->type = type;
1185         prop->subtype = subtype;
1186         prop->name = identifier;
1187         prop->description = "";
1188         prop->translation_context = BLT_I18NCONTEXT_DEFAULT_BPYRNA;
1189         /* a priori not raw editable */
1190         prop->rawtype = -1;
1191
1192         if (type != PROP_COLLECTION && type != PROP_POINTER) {
1193                 prop->flag = PROP_EDITABLE;
1194         
1195                 if (type != PROP_STRING) {
1196 #ifdef RNA_RUNTIME
1197                         prop->flag |= PROP_ANIMATABLE;
1198 #else
1199                         if (DefRNA.animate) {
1200                                 prop->flag |= PROP_ANIMATABLE;
1201                         }
1202 #endif
1203                 }
1204         }
1205
1206         if (type == PROP_STRING) {
1207                 /* used so generated 'get/length/set' functions skip a NULL check
1208                  * in some cases we want it */
1209                 RNA_def_property_flag(prop, PROP_NEVER_NULL);
1210         }
1211
1212         if (DefRNA.preprocess) {
1213                 switch (type) {
1214                         case PROP_BOOLEAN:
1215                                 DefRNA.silent = 1;
1216                                 RNA_def_property_boolean_sdna(prop, NULL, identifier, 0);
1217                                 DefRNA.silent = 0;
1218                                 break;
1219                         case PROP_INT:
1220                         {
1221                                 DefRNA.silent = 1;
1222                                 RNA_def_property_int_sdna(prop, NULL, identifier);
1223                                 DefRNA.silent = 0;
1224                                 break;
1225                         }
1226                         case PROP_FLOAT:
1227                         {
1228                                 DefRNA.silent = 1;
1229                                 RNA_def_property_float_sdna(prop, NULL, identifier);
1230                                 DefRNA.silent = 0;
1231                                 break;
1232                         }
1233                         case PROP_STRING:
1234                         {
1235                                 DefRNA.silent = 1;
1236                                 RNA_def_property_string_sdna(prop, NULL, identifier);
1237                                 DefRNA.silent = 0;
1238                                 break;
1239                         }
1240                         case PROP_ENUM:
1241                                 DefRNA.silent = 1;
1242                                 RNA_def_property_enum_sdna(prop, NULL, identifier);
1243                                 DefRNA.silent = 0;
1244                                 break;
1245                         case PROP_POINTER:
1246                                 DefRNA.silent = 1;
1247                                 RNA_def_property_pointer_sdna(prop, NULL, identifier);
1248                                 DefRNA.silent = 0;
1249                                 break;
1250                         case PROP_COLLECTION:
1251                                 DefRNA.silent = 1;
1252                                 RNA_def_property_collection_sdna(prop, NULL, identifier, NULL);
1253                                 DefRNA.silent = 0;
1254                                 break;
1255                 }
1256         }
1257         else {
1258                 prop->flag |= PROP_IDPROPERTY;
1259                 prop->flag_internal |= PROP_INTERN_RUNTIME;
1260 #ifdef RNA_RUNTIME
1261                 if (cont->prophash)
1262                         BLI_ghash_insert(cont->prophash, (void *)prop->identifier, prop);
1263 #endif
1264         }
1265
1266         rna_addtail(&cont->properties, prop);
1267
1268         return prop;
1269 }
1270
1271 void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
1272 {
1273         prop->flag |= flag;
1274 }
1275
1276 void RNA_def_property_clear_flag(PropertyRNA *prop, PropertyFlag flag)
1277 {
1278         prop->flag &= ~flag;
1279 }
1280
1281 void RNA_def_parameter_flags(PropertyRNA *prop, PropertyFlag flag_property, ParameterFlag flag_parameter)
1282 {
1283         prop->flag |= flag_property;
1284         prop->flag_parameter |= flag_parameter;
1285 }
1286
1287 void RNA_def_parameter_clear_flags(PropertyRNA *prop, PropertyFlag flag_property, ParameterFlag flag_parameter)
1288 {
1289         prop->flag &= ~flag_property;
1290         prop->flag_parameter &= ~flag_parameter;
1291 }
1292
1293 void RNA_def_property_subtype(PropertyRNA *prop, PropertySubType subtype)
1294 {
1295         prop->subtype = subtype;
1296 }
1297
1298 void RNA_def_property_array(PropertyRNA *prop, int length)
1299 {
1300         StructRNA *srna = DefRNA.laststruct;
1301
1302         if (length < 0) {
1303                 fprintf(stderr, "%s: \"%s.%s\", array length must be zero of greater.\n", __func__,
1304                         srna->identifier, prop->identifier);
1305                 DefRNA.error = 1;
1306                 return;
1307         }
1308
1309         if (length > RNA_MAX_ARRAY_LENGTH) {
1310                 fprintf(stderr, "%s: \"%s.%s\", array length must be smaller than %d.\n", __func__,
1311                         srna->identifier, prop->identifier, RNA_MAX_ARRAY_LENGTH);
1312                 DefRNA.error = 1;
1313                 return;
1314         }
1315
1316         if (prop->arraydimension > 1) {
1317                 fprintf(stderr, "%s: \"%s.%s\", array dimensions has been set to %u but would be overwritten as 1.\n",
1318                         __func__, srna->identifier, prop->identifier, prop->arraydimension);
1319                 DefRNA.error = 1;
1320                 return;
1321         }
1322
1323         switch (prop->type) {
1324                 case PROP_BOOLEAN:
1325                 case PROP_INT:
1326                 case PROP_FLOAT:
1327                         prop->arraylength[0] = length;
1328                         prop->totarraylength = length;
1329                         prop->arraydimension = 1;
1330                         break;
1331                 default:
1332                         fprintf(stderr, "%s: \"%s.%s\", only boolean/int/float can be array.\n",
1333                                 __func__, srna->identifier, prop->identifier);
1334                         DefRNA.error = 1;
1335                         break;
1336         }
1337 }
1338
1339 /* common args for length */
1340 const int rna_matrix_dimsize_3x3[] = {3, 3};
1341 const int rna_matrix_dimsize_4x4[] = {4, 4};
1342 const int rna_matrix_dimsize_4x2[] = {4, 2};
1343
1344 void RNA_def_property_multi_array(PropertyRNA *prop, int dimension, const int length[])
1345 {
1346         StructRNA *srna = DefRNA.laststruct;
1347         int i;
1348         
1349         if (dimension < 1 || dimension > RNA_MAX_ARRAY_DIMENSION) {
1350                 fprintf(stderr, "%s: \"%s.%s\", array dimension must be between 1 and %d.\n",
1351                         __func__, srna->identifier, prop->identifier, RNA_MAX_ARRAY_DIMENSION);
1352                 DefRNA.error = 1;
1353                 return;
1354         }
1355
1356         switch (prop->type) {
1357                 case PROP_BOOLEAN:
1358                 case PROP_INT:
1359                 case PROP_FLOAT:
1360                         break;
1361                 default:
1362                         fprintf(stderr, "%s: \"%s.%s\", only boolean/int/float can be array.\n",
1363                                 __func__, srna->identifier, prop->identifier);
1364                         DefRNA.error = 1;
1365                         break;
1366         }
1367
1368         prop->arraydimension = dimension;
1369         prop->totarraylength = 0;
1370
1371         if (length) {
1372                 memcpy(prop->arraylength, length, sizeof(int) * dimension);
1373
1374                 prop->totarraylength = length[0];
1375                 for (i = 1; i < dimension; i++)
1376                         prop->totarraylength *= length[i];
1377         }
1378         else
1379                 memset(prop->arraylength, 0, sizeof(prop->arraylength));
1380
1381         /* TODO make sure arraylength values are sane  */
1382 }
1383
1384 void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description)
1385 {
1386         DESCR_CHECK(description, prop->identifier, NULL);
1387
1388         prop->name = name;
1389         prop->description = description;
1390 }
1391
1392 void RNA_def_property_ui_icon(PropertyRNA *prop, int icon, bool consecutive)
1393 {
1394         prop->icon = icon;
1395         if (consecutive)
1396                 prop->flag |= PROP_ICONS_CONSECUTIVE;
1397 }
1398
1399 /**
1400  * The values hare are a little confusing:
1401  *
1402  * \param step: Used as the value to increase/decrease when clicking on number buttons,
1403  * as well as scaling mouse input for click-dragging number buttons.
1404  * For floats this is (step * UI_PRECISION_FLOAT_SCALE), why? - nobody knows.
1405  * For ints, whole values are used.
1406  *
1407  * \param precision The number of zeros to show
1408  * (as a whole number - common range is 1 - 6), see PRECISION_FLOAT_MAX
1409  */
1410 void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
1411 {
1412         StructRNA *srna = DefRNA.laststruct;
1413
1414 #ifdef DEBUG
1415         if (min > max) {
1416                 fprintf(stderr, "%s: \"%s.%s\", min > max.\n",
1417                         __func__, srna->identifier, prop->identifier);
1418                 DefRNA.error = 1;
1419         }
1420
1421         if (step < 0 || step > 100) {
1422                 fprintf(stderr, "%s: \"%s.%s\", step outside range.\n",
1423                         __func__, srna->identifier, prop->identifier);
1424                 DefRNA.error = 1;
1425         }
1426
1427         if (precision < -1 || precision > 10) {
1428                 fprintf(stderr, "%s: \"%s.%s\", step outside range.\n",
1429                         __func__, srna->identifier, prop->identifier);
1430                 DefRNA.error = 1;
1431         }
1432 #endif
1433
1434         switch (prop->type) {
1435                 case PROP_INT:
1436                 {
1437                         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
1438                         iprop->softmin = (int)min;
1439                         iprop->softmax = (int)max;
1440                         iprop->step = (int)step;
1441                         break;
1442                 }
1443                 case PROP_FLOAT:
1444                 {
1445                         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
1446                         fprop->softmin = (float)min;
1447                         fprop->softmax = (float)max;
1448                         fprop->step = (float)step;
1449                         fprop->precision = (int)precision;
1450 #if 0 /* handy but annoying */
1451                         if (DefRNA.preprocess) {
1452                                 /* check we're not over PRECISION_FLOAT_MAX */
1453                                 if (fprop->precision > 6) {
1454                                         fprintf(stderr, "%s: \"%s.%s\", precision value over maximum.\n",
1455                                                 __func__, srna->identifier, prop->identifier);
1456                                         DefRNA.error = 1;
1457                                 }
1458                                 else if (fprop->precision < 1) {
1459                                         fprintf(stderr, "%s: \"%s.%s\", precision value under minimum.\n",
1460                                                 __func__, srna->identifier, prop->identifier);
1461                                         DefRNA.error = 1;
1462                                 }
1463                         }
1464 #endif
1465                         break;
1466                 }
1467                 default:
1468                         fprintf(stderr, "%s: \"%s.%s\", invalid type for ui range.\n",
1469                                 __func__, srna->identifier, prop->identifier);
1470                         DefRNA.error = 1;
1471                         break;
1472         }
1473 }
1474
1475 void RNA_def_property_range(PropertyRNA *prop, double min, double max)
1476 {
1477         StructRNA *srna = DefRNA.laststruct;
1478
1479 #ifdef DEBUG
1480         if (min > max) {
1481                 fprintf(stderr, "%s: \"%s.%s\", min > max.\n",
1482                         __func__, srna->identifier, prop->identifier);
1483                 DefRNA.error = 1;
1484         }
1485 #endif
1486
1487         switch (prop->type) {
1488                 case PROP_INT:
1489                 {
1490                         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
1491                         iprop->hardmin = (int)min;
1492                         iprop->hardmax = (int)max;
1493                         iprop->softmin = MAX2((int)min, iprop->hardmin);
1494                         iprop->softmax = MIN2((int)max, iprop->hardmax);
1495                         break;
1496                 }
1497                 case PROP_FLOAT:
1498                 {
1499                         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
1500                         fprop->hardmin = (float)min;
1501                         fprop->hardmax = (float)max;
1502                         fprop->softmin = MAX2((float)min, fprop->hardmin);
1503                         fprop->softmax = MIN2((float)max, fprop->hardmax);
1504                         break;
1505                 }
1506                 default:
1507                         fprintf(stderr, "%s: \"%s.%s\", invalid type for range.\n", __func__, srna->identifier, prop->identifier);
1508                         DefRNA.error = 1;
1509                         break;
1510         }
1511 }
1512
1513 void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
1514 {
1515         StructRNA *srna = DefRNA.laststruct;
1516
1517         if (!DefRNA.preprocess) {
1518                 fprintf(stderr, "%s \"%s.%s\": only during preprocessing.\n", __func__, srna->identifier, prop->identifier);
1519                 return;
1520         }
1521
1522         switch (prop->type) {
1523                 case PROP_POINTER:
1524                 {
1525                         PointerPropertyRNA *pprop = (PointerPropertyRNA *)prop;
1526                         pprop->type = (StructRNA *)type;
1527                         break;
1528                 }
1529                 case PROP_COLLECTION:
1530                 {
1531                         CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)prop;
1532                         cprop->item_type = (StructRNA *)type;
1533                         break;
1534                 }
1535                 default:
1536                         fprintf(stderr, "%s: \"%s.%s\", invalid type for struct type.\n",
1537                                 __func__, srna->identifier, prop->identifier);
1538                         DefRNA.error = 1;
1539                         break;
1540         }
1541 }
1542
1543 void RNA_def_property_struct_runtime(PropertyRNA *prop, StructRNA *type)
1544 {
1545         StructRNA *srna = DefRNA.laststruct;
1546
1547         if (DefRNA.preprocess) {
1548                 fprintf(stderr, "%s: only at runtime.\n", __func__);
1549                 return;
1550         }
1551
1552         switch (prop->type) {
1553                 case PROP_POINTER:
1554                 {
1555                         PointerPropertyRNA *pprop = (PointerPropertyRNA *)prop;
1556                         pprop->type = type;
1557
1558                         if (type && (type->flag & STRUCT_ID_REFCOUNT))
1559                                 prop->flag |= PROP_ID_REFCOUNT;
1560
1561                         break;
1562                 }
1563                 case PROP_COLLECTION:
1564                 {
1565                         CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)prop;
1566                         cprop->item_type = type;
1567                         break;
1568                 }
1569                 default:
1570                         fprintf(stderr, "%s: \"%s.%s\", invalid type for struct type.\n",
1571                                 __func__, srna->identifier, prop->identifier);
1572                         DefRNA.error = 1;
1573                         break;
1574         }
1575 }
1576
1577 void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item)
1578 {
1579         StructRNA *srna = DefRNA.laststruct;
1580         int i, defaultfound = 0;
1581
1582         switch (prop->type) {
1583                 case PROP_ENUM:
1584                 {
1585                         EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
1586                         eprop->item = (EnumPropertyItem *)item;
1587                         eprop->totitem = 0;
1588                         for (i = 0; item[i].identifier; i++) {
1589                                 eprop->totitem++;
1590
1591                                 if (item[i].identifier[0] && item[i].value == eprop->defaultvalue)
1592                                         defaultfound = 1;
1593                         }
1594
1595                         if (!defaultfound) {
1596                                 for (i = 0; item[i].identifier; i++) {
1597                                         if (item[i].identifier[0]) {
1598                                                 eprop->defaultvalue = item[i].value;
1599                                                 break;
1600                                         }
1601                                 }
1602                         }
1603
1604                         break;
1605                 }
1606                 default:
1607                         fprintf(stderr, "%s: \"%s.%s\", invalid type for struct type.\n",
1608                                 __func__, srna->identifier, prop->identifier);
1609                         DefRNA.error = 1;
1610                         break;
1611         }
1612 }
1613
1614 void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
1615 {
1616         StructRNA *srna = DefRNA.laststruct;
1617
1618         switch (prop->type) {
1619                 case PROP_STRING:
1620                 {
1621                         StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
1622                         sprop->maxlength = maxlength;
1623                         break;
1624                 }
1625                 default:
1626                         fprintf(stderr, "%s: \"%s.%s\", type is not string.\n", __func__, srna->identifier, prop->identifier);
1627                         DefRNA.error = 1;
1628                         break;
1629         }
1630 }
1631
1632 void RNA_def_property_boolean_default(PropertyRNA *prop, int value)
1633 {
1634         StructRNA *srna = DefRNA.laststruct;
1635
1636         switch (prop->type) {
1637                 case PROP_BOOLEAN:
1638                 {
1639                         BoolPropertyRNA *bprop = (BoolPropertyRNA *)prop;
1640                         BLI_assert(ELEM(value, false, true));
1641                         bprop->defaultvalue = value;
1642                         break;
1643                 }
1644                 default:
1645                         fprintf(stderr, "%s: \"%s.%s\", type is not boolean.\n", __func__, srna->identifier, prop->identifier);
1646                         DefRNA.error = 1;
1647                         break;
1648         }
1649 }
1650
1651 void RNA_def_property_boolean_array_default(PropertyRNA *prop, const int *array)
1652 {
1653         StructRNA *srna = DefRNA.laststruct;
1654
1655         switch (prop->type) {
1656                 case PROP_BOOLEAN:
1657                 {
1658                         BoolPropertyRNA *bprop = (BoolPropertyRNA *)prop;
1659                         bprop->defaultarray = array;
1660                         break;
1661                 }
1662                 default:
1663                         fprintf(stderr, "%s: \"%s.%s\", type is not boolean.\n", __func__, srna->identifier, prop->identifier);
1664                         DefRNA.error = 1;
1665                         break;
1666         }
1667 }
1668
1669 void RNA_def_property_int_default(PropertyRNA *prop, int value)
1670 {
1671         StructRNA *srna = DefRNA.laststruct;
1672
1673         switch (prop->type) {
1674                 case PROP_INT:
1675                 {
1676                         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
1677                         iprop->defaultvalue = value;
1678                         break;
1679                 }
1680                 default:
1681                         fprintf(stderr, "%s: \"%s.%s\", type is not int.\n", __func__, srna->identifier, prop->identifier);
1682                         DefRNA.error = 1;
1683                         break;
1684         }
1685 }
1686
1687 void RNA_def_property_int_array_default(PropertyRNA *prop, const int *array)
1688 {
1689         StructRNA *srna = DefRNA.laststruct;
1690
1691         switch (prop->type) {
1692                 case PROP_INT:
1693                 {
1694                         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
1695                         iprop->defaultarray = array;
1696                         break;
1697                 }
1698                 default:
1699                         fprintf(stderr, "%s: \"%s.%s\", type is not int.\n", __func__, srna->identifier, prop->identifier);
1700                         DefRNA.error = 1;
1701                         break;
1702         }
1703 }
1704
1705 void RNA_def_property_float_default(PropertyRNA *prop, float value)
1706 {
1707         StructRNA *srna = DefRNA.laststruct;
1708
1709         switch (prop->type) {
1710                 case PROP_FLOAT:
1711                 {
1712                         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
1713                         fprop->defaultvalue = value;
1714                         break;
1715                 }
1716                 default:
1717                         fprintf(stderr, "%s: \"%s.%s\", type is not float.\n", __func__, srna->identifier, prop->identifier);
1718                         DefRNA.error = 1;
1719                         break;
1720         }
1721 }
1722 /* array must remain valid after this function finishes */
1723 void RNA_def_property_float_array_default(PropertyRNA *prop, const float *array)
1724 {
1725         StructRNA *srna = DefRNA.laststruct;
1726
1727         switch (prop->type) {
1728                 case PROP_FLOAT:
1729                 {
1730                         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
1731                         fprop->defaultarray = array; /* WARNING, this array must not come from the stack and lost */
1732                         break;
1733                 }
1734                 default:
1735                         fprintf(stderr, "%s: \"%s.%s\", type is not float.\n", __func__, srna->identifier, prop->identifier);
1736                         DefRNA.error = 1;
1737                         break;
1738         }
1739 }
1740
1741 void RNA_def_property_string_default(PropertyRNA *prop, const char *value)
1742 {
1743         StructRNA *srna = DefRNA.laststruct;
1744
1745         switch (prop->type) {
1746                 case PROP_STRING:
1747                 {
1748                         StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
1749
1750                         if (value == NULL) {
1751                                 fprintf(stderr, "%s: \"%s.%s\", NULL string passed (dont call in this case).\n", __func__, srna->identifier, prop->identifier);
1752                                 DefRNA.error = 1;
1753                                 break;
1754                         }
1755
1756                         if (!value[0]) {
1757                                 fprintf(stderr, "%s: \"%s.%s\", empty string passed (dont call in this case).\n", __func__, srna->identifier, prop->identifier);
1758                                 DefRNA.error = 1;
1759                                 // BLI_assert(0);
1760                                 break;
1761                         }
1762
1763                         sprop->defaultvalue = value;
1764                         break;
1765                 }
1766                 default:
1767                         fprintf(stderr, "%s: \"%s.%s\", type is not string.\n", __func__, srna->identifier, prop->identifier);
1768                         DefRNA.error = 1;
1769                         break;
1770         }
1771 }
1772
1773 void RNA_def_property_enum_default(PropertyRNA *prop, int value)
1774 {
1775         StructRNA *srna = DefRNA.laststruct;
1776         int i, defaultfound = 0;
1777
1778         switch (prop->type) {
1779                 case PROP_ENUM:
1780                 {
1781                         EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
1782                         eprop->defaultvalue = value;
1783
1784                         if (prop->flag & PROP_ENUM_FLAG) {
1785                                 /* check all bits are accounted for */
1786                                 int totflag = 0;
1787                                 for (i = 0; i < eprop->totitem; i++) {
1788                                         if (eprop->item[i].identifier[0]) {
1789                                                 totflag |= eprop->item[i].value;
1790                                         }
1791                                 }
1792
1793                                 if (eprop->defaultvalue & ~totflag) {
1794                                         fprintf(stderr, "%s: \"%s.%s\", default includes unused bits (%d).\n",
1795                                                 __func__, srna->identifier, prop->identifier, eprop->defaultvalue & ~totflag);
1796                                         DefRNA.error = 1;
1797                                 }
1798                         }
1799                         else {
1800                                 for (i = 0; i < eprop->totitem; i++) {
1801                                         if (eprop->item[i].identifier[0] && eprop->item[i].value == eprop->defaultvalue)
1802                                                 defaultfound = 1;
1803                                 }
1804
1805                                 if (!defaultfound && eprop->totitem) {
1806                                         if (value == 0) {
1807                                                 eprop->defaultvalue = eprop->item[0].value;
1808                                         }
1809                                         else {
1810                                                 fprintf(stderr, "%s: \"%s.%s\", default is not in items.\n",
1811                                                         __func__, srna->identifier, prop->identifier);
1812                                                 DefRNA.error = 1;
1813                                         }
1814                                 }
1815                         }
1816
1817                         break;
1818                 }
1819                 default:
1820                         fprintf(stderr, "%s: \"%s.%s\", type is not enum.\n", __func__, srna->identifier, prop->identifier);
1821                         DefRNA.error = 1;
1822                         break;
1823         }
1824 }
1825
1826 /* SDNA */
1827
1828 static PropertyDefRNA *rna_def_property_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1829 {
1830         DNAStructMember smember;
1831         StructDefRNA *ds;
1832         PropertyDefRNA *dp;
1833
1834         dp = rna_find_struct_property_def(DefRNA.laststruct, prop);
1835         if (dp == NULL) return NULL;
1836
1837         ds = rna_find_struct_def((StructRNA *)dp->cont);
1838
1839         if (!structname)
1840                 structname = ds->dnaname;
1841         if (!propname)
1842                 propname = prop->identifier;
1843
1844         if (!rna_find_sdna_member(DefRNA.sdna, structname, propname, &smember)) {
1845                 if (DefRNA.silent) {
1846                         return NULL;
1847                 }
1848                 else if (!DefRNA.verify) {
1849                         /* some basic values to survive even with sdna info */
1850                         dp->dnastructname = structname;
1851                         dp->dnaname = propname;
1852                         if (prop->type == PROP_BOOLEAN)
1853                                 dp->dnaarraylength = 1;
1854                         if (prop->type == PROP_POINTER)
1855                                 dp->dnapointerlevel = 1;
1856                         return dp;
1857                 }
1858                 else {
1859                         fprintf(stderr, "%s: \"%s.%s\" (identifier \"%s\") not found.\n",
1860                                 __func__, structname, propname, prop->identifier);
1861                         DefRNA.error = 1;
1862                         return NULL;
1863                 }
1864         }
1865
1866         if (smember.arraylength > 1) {
1867                 prop->arraylength[0] = smember.arraylength;
1868                 prop->totarraylength = smember.arraylength;
1869                 prop->arraydimension = 1;
1870         }
1871         else {
1872                 prop->arraydimension = 0;
1873                 prop->totarraylength = 0;
1874         }
1875         
1876         dp->dnastructname = structname;
1877         dp->dnastructfromname = ds->dnafromname;
1878         dp->dnastructfromprop = ds->dnafromprop;
1879         dp->dnaname = propname;
1880         dp->dnatype = smember.type;
1881         dp->dnaarraylength = smember.arraylength;
1882         dp->dnapointerlevel = smember.pointerlevel;
1883
1884         return dp;
1885 }
1886
1887 void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int bit)
1888 {
1889         PropertyDefRNA *dp;
1890         StructRNA *srna = DefRNA.laststruct;
1891         
1892         if (!DefRNA.preprocess) {
1893                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1894                 return;
1895         }
1896
1897         if (prop->type != PROP_BOOLEAN) {
1898                 fprintf(stderr, "%s: \"%s.%s\", type is not boolean.\n", __func__, srna->identifier, prop->identifier);
1899                 DefRNA.error = 1;
1900                 return;
1901         }
1902
1903         if ((dp = rna_def_property_sdna(prop, structname, propname))) {
1904
1905                 if (DefRNA.silent == 0) {
1906                         /* error check to ensure floats are not wrapped as ints/bools */
1907                         if (dp->dnatype && *dp->dnatype && IS_DNATYPE_INT_COMPAT(dp->dnatype) == 0) {
1908                                 fprintf(stderr, "%s: %s.%s is a '%s' but wrapped as type '%s'.\n",
1909                                         __func__, srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
1910                                 DefRNA.error = 1;
1911                                 return;
1912                         }
1913                 }
1914
1915                 dp->booleanbit = bit;
1916         }
1917 }
1918
1919 void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname,
1920                                             const char *propname, int booleanbit)
1921 {
1922         PropertyDefRNA *dp;
1923
1924         RNA_def_property_boolean_sdna(prop, structname, propname, booleanbit);
1925
1926         dp = rna_find_struct_property_def(DefRNA.laststruct, prop);
1927
1928         if (dp)
1929                 dp->booleannegative = 1;
1930 }
1931
1932 void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1933 {
1934         PropertyDefRNA *dp;
1935         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
1936         StructRNA *srna = DefRNA.laststruct;
1937         
1938         if (!DefRNA.preprocess) {
1939                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1940                 return;
1941         }
1942
1943         if (prop->type != PROP_INT) {
1944                 fprintf(stderr, "%s: \"%s.%s\", type is not int.\n", __func__, srna->identifier, prop->identifier);
1945                 DefRNA.error = 1;
1946                 return;
1947         }
1948
1949         if ((dp = rna_def_property_sdna(prop, structname, propname))) {
1950
1951                 /* error check to ensure floats are not wrapped as ints/bools */
1952                 if (DefRNA.silent == 0) {
1953                         if (dp->dnatype && *dp->dnatype && IS_DNATYPE_INT_COMPAT(dp->dnatype) == 0) {
1954                                 fprintf(stderr, "%s: %s.%s is a '%s' but wrapped as type '%s'.\n",
1955                                         __func__, srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
1956                                 DefRNA.error = 1;
1957                                 return;
1958                         }
1959                 }
1960
1961                 /* SDNA doesn't pass us unsigned unfortunately .. */
1962                 if (dp->dnatype && STREQ(dp->dnatype, "char")) {
1963                         iprop->hardmin = iprop->softmin = CHAR_MIN;
1964                         iprop->hardmax = iprop->softmax = CHAR_MAX;
1965                 }
1966                 else if (dp->dnatype && STREQ(dp->dnatype, "short")) {
1967                         iprop->hardmin = iprop->softmin = SHRT_MIN;
1968                         iprop->hardmax = iprop->softmax = SHRT_MAX;
1969                 }
1970                 else if (dp->dnatype && STREQ(dp->dnatype, "int")) {
1971                         iprop->hardmin = INT_MIN;
1972                         iprop->hardmax = INT_MAX;
1973
1974                         iprop->softmin = -10000; /* rather arbitrary .. */
1975                         iprop->softmax = 10000;
1976                 }
1977
1978                 if (prop->subtype == PROP_UNSIGNED || prop->subtype == PROP_PERCENTAGE || prop->subtype == PROP_FACTOR)
1979                         iprop->hardmin = iprop->softmin = 0;
1980         }
1981 }
1982
1983 void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1984 {
1985         PropertyDefRNA *dp;
1986         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
1987         StructRNA *srna = DefRNA.laststruct;
1988
1989         if (!DefRNA.preprocess) {
1990                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1991                 return;
1992         }
1993
1994         if (prop->type != PROP_FLOAT) {
1995                 fprintf(stderr, "%s: \"%s.%s\", type is not float.\n", __func__, srna->identifier, prop->identifier);
1996                 DefRNA.error = 1;
1997                 return;
1998         }
1999
2000         if ((dp = rna_def_property_sdna(prop, structname, propname))) {
2001                 /* silent is for internal use */
2002                 if (DefRNA.silent == 0) {
2003                         if (dp->dnatype && *dp->dnatype && IS_DNATYPE_FLOAT_COMPAT(dp->dnatype) == 0) {
2004                                 if (prop->subtype != PROP_COLOR_GAMMA) { /* colors are an exception. these get translated */
2005                                         fprintf(stderr, "%s: %s.%s is a '%s' but wrapped as type '%s'.\n",
2006                                                 __func__, srna->identifier, prop->identifier, dp->dnatype,
2007                                                 RNA_property_typename(prop->type));
2008                                         DefRNA.error = 1;
2009                                         return;
2010                                 }
2011                         }
2012                 }
2013
2014                 if (dp->dnatype && STREQ(dp->dnatype, "char")) {
2015                         fprop->hardmin = fprop->softmin = 0.0f;
2016                         fprop->hardmax = fprop->softmax = 1.0f;
2017                 }
2018         }
2019
2020         rna_def_property_sdna(prop, structname, propname);
2021 }
2022
2023 void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname)
2024 {
2025         /* PropertyDefRNA *dp; */
2026         StructRNA *srna = DefRNA.laststruct;
2027         
2028         if (!DefRNA.preprocess) {
2029                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2030                 return;
2031         }
2032
2033         if (prop->type != PROP_ENUM) {
2034                 fprintf(stderr, "%s: \"%s.%s\", type is not enum.\n", __func__, srna->identifier, prop->identifier);
2035                 DefRNA.error = 1;
2036                 return;
2037         }
2038
2039         if ((/* dp= */ rna_def_property_sdna(prop, structname, propname))) {
2040                 if (prop->arraydimension) {
2041                         prop->arraydimension = 0;
2042                         prop->totarraylength = 0;
2043
2044                         if (!DefRNA.silent) {
2045                                 fprintf(stderr, "%s: \"%s.%s\", array not supported for enum type.\n",
2046                                         __func__, structname, propname);
2047                                 DefRNA.error = 1;
2048                         }
2049                 }
2050         }
2051 }
2052
2053 void RNA_def_property_enum_bitflag_sdna(PropertyRNA *prop, const char *structname, const char *propname)
2054 {
2055         PropertyDefRNA *dp;
2056
2057         RNA_def_property_enum_sdna(prop, structname, propname);
2058
2059         dp = rna_find_struct_property_def(DefRNA.laststruct, prop);
2060
2061         if (dp)
2062                 dp->enumbitflags = 1;
2063 }
2064
2065 void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, const char *propname)
2066 {
2067         /* PropertyDefRNA *dp; */
2068         StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
2069         StructRNA *srna = DefRNA.laststruct;
2070
2071         if (!DefRNA.preprocess) {
2072                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2073                 return;
2074         }
2075
2076         if (prop->type != PROP_STRING) {
2077                 fprintf(stderr, "%s: \"%s.%s\", type is not string.\n", __func__, srna->identifier, prop->identifier);
2078                 DefRNA.error = 1;
2079                 return;
2080         }
2081
2082         if ((/* dp= */ rna_def_property_sdna(prop, structname, propname))) {
2083                 if (prop->arraydimension) {
2084                         sprop->maxlength = prop->totarraylength;
2085                         prop->arraydimension = 0;
2086                         prop->totarraylength = 0;
2087                 }
2088         }
2089 }
2090
2091 void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname)
2092 {
2093         /* PropertyDefRNA *dp; */
2094         StructRNA *srna = DefRNA.laststruct;
2095         
2096         if (!DefRNA.preprocess) {
2097                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2098                 return;
2099         }
2100
2101         if (prop->type != PROP_POINTER) {
2102                 fprintf(stderr, "%s: \"%s.%s\", type is not pointer.\n", __func__, srna->identifier, prop->identifier);
2103                 DefRNA.error = 1;
2104                 return;
2105         }
2106
2107         if ((/* dp= */ rna_def_property_sdna(prop, structname, propname))) {
2108                 if (prop->arraydimension) {
2109                         prop->arraydimension = 0;
2110                         prop->totarraylength = 0;
2111
2112                         if (!DefRNA.silent) {
2113                                 fprintf(stderr, "%s: \"%s.%s\", array not supported for pointer type.\n",
2114                                         __func__, structname, propname);
2115                                 DefRNA.error = 1;
2116                         }
2117                 }
2118         }
2119 }
2120
2121 void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname,
2122                                       const char *lengthpropname)
2123 {
2124         PropertyDefRNA *dp;
2125         CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)prop;
2126         StructRNA *srna = DefRNA.laststruct;
2127
2128         if (!DefRNA.preprocess) {
2129                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2130                 return;
2131         }
2132
2133         if (prop->type != PROP_COLLECTION) {
2134                 fprintf(stderr, "%s: \"%s.%s\", type is not collection.\n", __func__, srna->identifier, prop->identifier);
2135                 DefRNA.error = 1;
2136                 return;
2137         }
2138
2139         if ((dp = rna_def_property_sdna(prop, structname, propname))) {
2140                 if (prop->arraydimension && !lengthpropname) {
2141                         prop->arraydimension = 0;
2142                         prop->totarraylength = 0;
2143
2144                         if (!DefRNA.silent) {
2145                                 fprintf(stderr, "%s: \"%s.%s\", array of collections not supported.\n",
2146                                         __func__, structname, propname);
2147                                 DefRNA.error = 1;
2148                         }
2149                 }
2150
2151                 if (dp->dnatype && STREQ(dp->dnatype, "ListBase")) {
2152                         cprop->next = (PropCollectionNextFunc)"rna_iterator_listbase_next";
2153                         cprop->get = (PropCollectionGetFunc)"rna_iterator_listbase_get";
2154                         cprop->end = (PropCollectionEndFunc)"rna_iterator_listbase_end";
2155                 }
2156         }
2157
2158         if (dp && lengthpropname) {
2159                 DNAStructMember smember;
2160                 StructDefRNA *ds = rna_find_struct_def((StructRNA *)dp->cont);
2161
2162                 if (!structname)
2163                         structname = ds->dnaname;
2164
2165                 if (lengthpropname[0] == 0 || rna_find_sdna_member(DefRNA.sdna, structname, lengthpropname, &smember)) {
2166                         if (lengthpropname[0] == 0) {
2167                                 dp->dnalengthfixed = prop->totarraylength;
2168                                 prop->arraydimension = 0;
2169                                 prop->totarraylength = 0;
2170                         }
2171                         else {
2172                                 dp->dnalengthstructname = structname;
2173                                 dp->dnalengthname = lengthpropname;
2174                                 prop->totarraylength = 0;
2175                         }
2176
2177                         cprop->next = (PropCollectionNextFunc)"rna_iterator_array_next";
2178                         cprop->end = (PropCollectionEndFunc)"rna_iterator_array_end";
2179
2180                         if (dp->dnapointerlevel >= 2)
2181                                 cprop->get = (PropCollectionGetFunc)"rna_iterator_array_dereference_get";
2182                         else
2183                                 cprop->get = (PropCollectionGetFunc)"rna_iterator_array_get";
2184                 }
2185                 else {
2186                         if (!DefRNA.silent) {
2187                                 fprintf(stderr, "%s: \"%s.%s\" not found.\n", __func__, structname, lengthpropname);
2188                                 DefRNA.error = 1;
2189                         }
2190                 }
2191         }
2192 }
2193
2194 void RNA_def_property_translation_context(PropertyRNA *prop, const char *context)
2195 {
2196         prop->translation_context = context ? context : BLT_I18NCONTEXT_DEFAULT_BPYRNA;
2197 }
2198
2199 /* Functions */
2200
2201 void RNA_def_property_editable_func(PropertyRNA *prop, const char *editable)
2202 {
2203         if (!DefRNA.preprocess) {
2204                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2205                 return;
2206         }
2207
2208         if (editable) prop->editable = (EditableFunc)editable;
2209 }
2210
2211 void RNA_def_property_editable_array_func(PropertyRNA *prop, const char *editable)
2212 {
2213         if (!DefRNA.preprocess) {
2214                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2215                 return;
2216         }
2217
2218         if (editable) prop->itemeditable = (ItemEditableFunc)editable;
2219 }
2220
2221 void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *func)
2222 {
2223         if (!DefRNA.preprocess) {
2224                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2225                 return;
2226         }
2227
2228         prop->noteflag = noteflag;
2229         prop->update = (UpdateFunc)func;
2230 }
2231
2232 void RNA_def_property_update_runtime(PropertyRNA *prop, const void *func)
2233 {
2234         prop->update = (void *)func;
2235 }
2236
2237 void RNA_def_property_poll_runtime(PropertyRNA *prop, const void *func)
2238 {
2239         if (prop->type == PROP_POINTER) {
2240                 ((PointerPropertyRNA *)prop)->poll = func;
2241         }
2242         else {
2243                 fprintf(stderr, "%s: %s is not a Pointer Property.\n", __func__, prop->identifier);
2244         }
2245 }
2246
2247 void RNA_def_property_dynamic_array_funcs(PropertyRNA *prop, const char *getlength)
2248 {
2249         if (!DefRNA.preprocess) {
2250                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2251                 return;
2252         }
2253
2254         if (!(prop->flag & PROP_DYNAMIC)) {
2255                 fprintf(stderr, "%s: property is a not dynamic array.\n", __func__);
2256                 DefRNA.error = 1;
2257                 return;
2258         }
2259
2260         if (getlength) prop->getlength = (PropArrayLengthGetFunc)getlength;
2261 }
2262
2263 void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
2264 {
2265         StructRNA *srna = DefRNA.laststruct;
2266
2267         if (!DefRNA.preprocess) {
2268                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2269                 return;
2270         }
2271
2272         switch (prop->type) {
2273                 case PROP_BOOLEAN:
2274                 {
2275                         BoolPropertyRNA *bprop = (BoolPropertyRNA *)prop;
2276
2277                         if (prop->arraydimension) {
2278                                 if (get) bprop->getarray = (PropBooleanArrayGetFunc)get;
2279                                 if (set) bprop->setarray = (PropBooleanArraySetFunc)set;
2280                         }
2281                         else {
2282                                 if (get) bprop->get = (PropBooleanGetFunc)get;
2283                                 if (set) bprop->set = (PropBooleanSetFunc)set;
2284                         }
2285                         break;
2286                 }
2287                 default:
2288                         fprintf(stderr, "%s: \"%s.%s\", type is not boolean.\n", __func__, srna->identifier, prop->identifier);
2289                         DefRNA.error = 1;
2290                         break;
2291         }
2292 }
2293
2294 void RNA_def_property_boolean_funcs_runtime(PropertyRNA *prop, BooleanPropertyGetFunc getfunc, BooleanPropertySetFunc setfunc)
2295 {
2296         BoolPropertyRNA *bprop = (BoolPropertyRNA *)prop;
2297
2298         if (getfunc) bprop->get_ex = getfunc;
2299         if (setfunc) bprop->set_ex = setfunc;
2300
2301         if (getfunc || setfunc) {
2302                 /* don't save in id properties */
2303                 prop->flag &= ~PROP_IDPROPERTY;
2304
2305                 if (!setfunc)
2306                         prop->flag &= ~PROP_EDITABLE;
2307         }
2308 }
2309
2310 void RNA_def_property_boolean_array_funcs_runtime(PropertyRNA *prop, BooleanArrayPropertyGetFunc getfunc, BooleanArrayPropertySetFunc setfunc)
2311 {
2312         BoolPropertyRNA *bprop = (BoolPropertyRNA *)prop;
2313
2314         if (getfunc) bprop->getarray_ex = getfunc;
2315         if (setfunc) bprop->setarray_ex = setfunc;
2316
2317         if (getfunc || setfunc) {
2318                 /* don't save in id properties */
2319                 prop->flag &= ~PROP_IDPROPERTY;
2320
2321                 if (!setfunc)
2322                         prop->flag &= ~PROP_EDITABLE;
2323         }
2324 }
2325
2326 void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
2327 {
2328         StructRNA *srna = DefRNA.laststruct;
2329
2330         if (!DefRNA.preprocess) {
2331                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2332                 return;
2333         }
2334
2335         switch (prop->type) {
2336                 case PROP_INT:
2337                 {
2338                         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
2339
2340                         if (prop->arraydimension) {
2341                                 if (get) iprop->getarray = (PropIntArrayGetFunc)get;
2342                                 if (set) iprop->setarray = (PropIntArraySetFunc)set;
2343                         }
2344                         else {
2345                                 if (get) iprop->get = (PropIntGetFunc)get;
2346                                 if (set) iprop->set = (PropIntSetFunc)set;
2347                         }
2348                         if (range) iprop->range = (PropIntRangeFunc)range;
2349                         break;
2350                 }
2351                 default:
2352                         fprintf(stderr, "%s: \"%s.%s\", type is not int.\n", __func__, srna->identifier, prop->identifier);
2353                         DefRNA.error = 1;
2354                         break;
2355         }
2356 }
2357
2358 void RNA_def_property_int_funcs_runtime(PropertyRNA *prop, IntPropertyGetFunc getfunc, IntPropertySetFunc setfunc, IntPropertyRangeFunc rangefunc)
2359 {
2360         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
2361
2362         if (getfunc) iprop->get_ex = getfunc;
2363         if (setfunc) iprop->set_ex = setfunc;
2364         if (rangefunc) iprop->range_ex = rangefunc;
2365
2366         if (getfunc || setfunc) {
2367                 /* don't save in id properties */
2368                 prop->flag &= ~PROP_IDPROPERTY;
2369
2370                 if (!setfunc)
2371                         prop->flag &= ~PROP_EDITABLE;
2372         }
2373 }
2374
2375 void RNA_def_property_int_array_funcs_runtime(PropertyRNA *prop, IntArrayPropertyGetFunc getfunc, IntArrayPropertySetFunc setfunc, IntPropertyRangeFunc rangefunc)
2376 {
2377         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
2378
2379         if (getfunc) iprop->getarray_ex = getfunc;
2380         if (setfunc) iprop->setarray_ex = setfunc;
2381         if (rangefunc) iprop->range_ex = rangefunc;
2382
2383         if (getfunc || setfunc) {
2384                 /* don't save in id properties */
2385                 prop->flag &= ~PROP_IDPROPERTY;
2386
2387                 if (!setfunc)
2388                         prop->flag &= ~PROP_EDITABLE;
2389         }
2390 }
2391
2392 void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
2393 {
2394         StructRNA *srna = DefRNA.laststruct;
2395
2396         if (!DefRNA.preprocess) {
2397                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2398                 return;
2399         }
2400
2401         switch (prop->type) {
2402                 case PROP_FLOAT:
2403                 {
2404                         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
2405
2406                         if (prop->arraydimension) {
2407                                 if (get) fprop->getarray = (PropFloatArrayGetFunc)get;
2408                                 if (set) fprop->setarray = (PropFloatArraySetFunc)set;
2409                         }
2410                         else {
2411                                 if (get) fprop->get = (PropFloatGetFunc)get;
2412                                 if (set) fprop->set = (PropFloatSetFunc)set;
2413                         }
2414                         if (range) fprop->range = (PropFloatRangeFunc)range;
2415                         break;
2416                 }
2417                 default:
2418                         fprintf(stderr, "%s: \"%s.%s\", type is not float.\n", __func__, srna->identifier, prop->identifier);
2419                         DefRNA.error = 1;
2420                         break;
2421         }
2422 }
2423
2424 void RNA_def_property_float_funcs_runtime(PropertyRNA *prop, FloatPropertyGetFunc getfunc, FloatPropertySetFunc setfunc, FloatPropertyRangeFunc rangefunc)
2425 {
2426         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
2427
2428         if (getfunc) fprop->get_ex = getfunc;
2429         if (setfunc) fprop->set_ex = setfunc;
2430         if (rangefunc) fprop->range_ex = rangefunc;
2431
2432         if (getfunc || setfunc) {
2433                 /* don't save in id properties */
2434                 prop->flag &= ~PROP_IDPROPERTY;
2435
2436                 if (!setfunc)
2437                         prop->flag &= ~PROP_EDITABLE;
2438         }
2439 }
2440
2441 void RNA_def_property_float_array_funcs_runtime(PropertyRNA *prop, FloatArrayPropertyGetFunc getfunc, FloatArrayPropertySetFunc setfunc, FloatPropertyRangeFunc rangefunc)
2442 {
2443         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
2444
2445         if (getfunc) fprop->getarray_ex = getfunc;
2446         if (setfunc) fprop->setarray_ex = setfunc;
2447         if (rangefunc) fprop->range_ex = rangefunc;
2448
2449         if (getfunc || setfunc) {
2450                 /* don't save in id properties */
2451                 prop->flag &= ~PROP_IDPROPERTY;
2452
2453                 if (!setfunc)
2454                         prop->flag &= ~PROP_EDITABLE;
2455         }
2456 }
2457
2458 void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char *set, const char *item)
2459 {
2460         StructRNA *srna = DefRNA.laststruct;
2461
2462         if (!DefRNA.preprocess) {
2463                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2464                 return;
2465         }
2466
2467         switch (prop->type) {
2468                 case PROP_ENUM:
2469                 {
2470                         EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
2471
2472                         if (get) eprop->get = (PropEnumGetFunc)get;
2473                         if (set) eprop->set = (PropEnumSetFunc)set;
2474                         if (item) eprop->itemf = (PropEnumItemFunc)item;
2475                         break;
2476                 }
2477                 default:
2478                         fprintf(stderr, "%s: \"%s.%s\", type is not enum.\n", __func__, srna->identifier, prop->identifier);
2479                         DefRNA.error = 1;
2480                         break;
2481         }
2482 }
2483
2484 void RNA_def_property_enum_funcs_runtime(PropertyRNA *prop, EnumPropertyGetFunc getfunc, EnumPropertySetFunc setfunc, EnumPropertyItemFunc itemfunc)
2485 {
2486         EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
2487
2488         if (getfunc) eprop->get_ex = getfunc;
2489         if (setfunc) eprop->set_ex = setfunc;
2490         if (itemfunc) eprop->itemf = itemfunc;
2491
2492         if (getfunc || setfunc) {
2493                 /* don't save in id properties */
2494                 prop->flag &= ~PROP_IDPROPERTY;
2495
2496                 if (!setfunc)
2497                         prop->flag &= ~PROP_EDITABLE;
2498         }
2499 }
2500
2501 void RNA_def_property_enum_py_data(PropertyRNA *prop, void *py_data)
2502 {
2503         EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
2504         eprop->py_data = py_data;
2505 }
2506
2507 void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
2508 {
2509         StructRNA *srna = DefRNA.laststruct;
2510
2511         if (!DefRNA.preprocess) {
2512                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2513                 return;
2514         }
2515
2516         switch (prop->type) {
2517                 case PROP_STRING:
2518                 {
2519                         StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
2520
2521                         if (get) sprop->get = (PropStringGetFunc)get;
2522                         if (length) sprop->length = (PropStringLengthFunc)length;
2523                         if (set) sprop->set = (PropStringSetFunc)set;
2524                         break;
2525                 }
2526                 default:
2527                         fprintf(stderr, "%s: \"%s.%s\", type is not string.\n", __func__, srna->identifier, prop->identifier);
2528                         DefRNA.error = 1;
2529                         break;
2530         }
2531 }
2532
2533 void RNA_def_property_string_funcs_runtime(PropertyRNA *prop, StringPropertyGetFunc getfunc, StringPropertyLengthFunc lengthfunc, StringPropertySetFunc setfunc)
2534 {
2535         StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
2536
2537         if (getfunc) sprop->get_ex = getfunc;
2538         if (lengthfunc) sprop->length_ex = lengthfunc;
2539         if (setfunc) sprop->set_ex = setfunc;
2540
2541         if (getfunc || setfunc) {
2542                 /* don't save in id properties */
2543                 prop->flag &= ~PROP_IDPROPERTY;
2544
2545                 if (!setfunc)
2546                         prop->flag &= ~PROP_EDITABLE;
2547         }
2548 }
2549
2550 void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set,
2551                                     const char *typef, const char *poll)
2552 {
2553         StructRNA *srna = DefRNA.laststruct;
2554
2555         if (!DefRNA.preprocess) {
2556                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2557                 return;
2558         }
2559
2560         switch (prop->type) {
2561                 case PROP_POINTER:
2562                 {
2563                         PointerPropertyRNA *pprop = (PointerPropertyRNA *)prop;
2564
2565                         if (get) pprop->get = (PropPointerGetFunc)get;
2566                         if (set) pprop->set = (PropPointerSetFunc)set;
2567                         if (typef) pprop->typef = (PropPointerTypeFunc)typef;
2568                         if (poll) pprop->poll = (PropPointerPollFunc)poll;
2569                         break;
2570                 }
2571                 default:
2572                         fprintf(stderr, "%s: \"%s.%s\", type is not pointer.\n", __func__, srna->identifier, prop->identifier);
2573                         DefRNA.error = 1;
2574                         break;
2575         }
2576 }
2577
2578 void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, const char *next, const char *end,
2579                                        const char *get, const char *length, const char *lookupint,
2580                                        const char *lookupstring, const char *assignint)
2581 {
2582         StructRNA *srna = DefRNA.laststruct;
2583
2584         if (!DefRNA.preprocess) {
2585                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2586                 return;
2587         }
2588
2589         switch (prop->type) {
2590                 case PROP_COLLECTION:
2591                 {
2592                         CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)prop;
2593
2594                         if (begin) cprop->begin = (PropCollectionBeginFunc)begin;
2595                         if (next) cprop->next = (PropCollectionNextFunc)next;
2596                         if (end) cprop->end = (PropCollectionEndFunc)end;
2597                         if (get) cprop->get = (PropCollectionGetFunc)get;
2598                         if (length) cprop->length = (PropCollectionLengthFunc)length;
2599                         if (lookupint) cprop->lookupint = (PropCollectionLookupIntFunc)lookupint;
2600                         if (lookupstring) cprop->lookupstring = (PropCollectionLookupStringFunc)lookupstring;
2601                         if (assignint) cprop->assignint = (PropCollectionAssignIntFunc)assignint;
2602                         break;
2603                 }
2604                 default:
2605                         fprintf(stderr, "%s: \"%s.%s\", type is not collection.\n", __func__, srna->identifier, prop->identifier);
2606                         DefRNA.error = 1;
2607                         break;
2608         }
2609 }
2610
2611 void RNA_def_property_srna(PropertyRNA *prop, const char *type)
2612 {
2613         prop->srna = (StructRNA *)type;
2614 }
2615
2616 void RNA_def_py_data(PropertyRNA *prop, void *py_data)
2617 {
2618         prop->py_data = py_data;
2619 }
2620
2621 /* Compact definitions */
2622
2623 PropertyRNA *RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, int default_value,
2624                              const char *ui_name, const char *ui_description)
2625 {
2626         ContainerRNA *cont = cont_;
2627         PropertyRNA *prop;
2628         
2629         prop = RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_NONE);
2630         RNA_def_property_boolean_default(prop, default_value);
2631         RNA_def_property_ui_text(prop, ui_name, ui_description);
2632
2633         return prop;
2634 }
2635
2636 PropertyRNA *RNA_def_boolean_array(StructOrFunctionRNA *cont_, const char *identifier, int len, int *default_value,
2637                                    const char *ui_name, const char *ui_description)
2638 {
2639         ContainerRNA *cont = cont_;
2640         PropertyRNA *prop;
2641         
2642         prop = RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_NONE);
2643         if (len != 0) RNA_def_property_array(prop, len);
2644         if (default_value) RNA_def_property_boolean_array_default(prop, default_value);
2645         RNA_def_property_ui_text(prop, ui_name, ui_description);
2646
2647         return prop;
2648 }
2649
2650 PropertyRNA *RNA_def_boolean_layer(StructOrFunctionRNA *cont_, const char *identifier, int len, int *default_value,
2651                                    const char *ui_name, const char *ui_description)
2652 {
2653         ContainerRNA *cont = cont_;
2654         PropertyRNA *prop;
2655         
2656         prop = RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_LAYER);
2657         if (len != 0) RNA_def_property_array(prop, len);
2658         if (default_value) RNA_def_property_boolean_array_default(prop, default_value);
2659         RNA_def_property_ui_text(prop, ui_name, ui_description);
2660
2661         return prop;
2662 }
2663
2664 PropertyRNA *RNA_def_boolean_layer_member(StructOrFunctionRNA *cont_, const char *identifier, int len,
2665                                           int *default_value, const char *ui_name, const char *ui_description)
2666 {
2667         ContainerRNA *cont = cont_;
2668         PropertyRNA *prop;
2669         
2670         prop = RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_LAYER_MEMBER);
2671         if (len != 0) RNA_def_property_array(prop, len);
2672         if (default_value) RNA_def_property_boolean_array_default(prop, default_value);
2673         RNA_def_property_ui_text(prop, ui_name, ui_description);
2674
2675         return prop;
2676 }
2677
2678 PropertyRNA *RNA_def_boolean_vector(StructOrFunctionRNA *cont_, const char *identifier, int len, int *default_value,
2679                                     const char *ui_name, const char *ui_description)
2680 {
2681         ContainerRNA *cont = cont_;
2682         PropertyRNA *prop;
2683         
2684         prop = RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_XYZ); /* XXX */
2685         if (len != 0) RNA_def_property_array(prop, len);
2686         if (default_value) RNA_def_property_boolean_array_default(prop, default_value);
2687         RNA_def_property_ui_text(prop, ui_name, ui_description);
2688
2689         return prop;
2690 }
2691
2692 PropertyRNA *RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, int default_value,
2693                          int hardmin, int hardmax, const char *ui_name, const char *ui_description,
2694                          int softmin, int softmax)
2695 {
2696         ContainerRNA *cont = cont_;
2697         PropertyRNA *prop;
2698         
2699         ASSERT_SOFT_HARD_LIMITS;
2700
2701         prop = RNA_def_property(cont, identifier, PROP_INT, PROP_NONE);
2702         RNA_def_property_int_default(prop, default_value);
2703         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2704         RNA_def_property_ui_text(prop, ui_name, ui_description);
2705         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2706
2707         return prop;
2708 }
2709
2710 PropertyRNA *RNA_def_int_vector(StructOrFunctionRNA *cont_, const char *identifier, int len, const int *default_value,
2711                                 int hardmin, int hardmax, const char *ui_name, const char *ui_description,
2712                                 int softmin, int softmax)
2713 {
2714         ContainerRNA *cont = cont_;
2715         PropertyRNA *prop;
2716         
2717         ASSERT_SOFT_HARD_LIMITS;
2718
2719         prop = RNA_def_property(cont, identifier, PROP_INT, PROP_XYZ); /* XXX */
2720         if (len != 0) RNA_def_property_array(prop, len);
2721         if (default_value) RNA_def_property_int_array_default(prop, default_value);
2722         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2723         RNA_def_property_ui_text(prop, ui_name, ui_description);
2724         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2725
2726         return prop;
2727 }
2728
2729 PropertyRNA *RNA_def_int_array(StructOrFunctionRNA *cont_, const char *identifier, int len, const int *default_value,
2730                                int hardmin, int hardmax, const char *ui_name, const char *ui_description,
2731                                int softmin, int softmax)
2732 {
2733         ContainerRNA *cont = cont_;
2734         PropertyRNA *prop;
2735         
2736         ASSERT_SOFT_HARD_LIMITS;
2737
2738         prop = RNA_def_property(cont, identifier, PROP_INT, PROP_NONE);
2739         if (len != 0) RNA_def_property_array(prop, len);
2740         if (default_value) RNA_def_property_int_array_default(prop, default_value);
2741         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2742         RNA_def_property_ui_text(prop, ui_name, ui_description);
2743         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2744
2745         return prop;
2746 }
2747
2748 PropertyRNA *RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, int maxlen,
2749                             const char *ui_name, const char *ui_description)
2750 {
2751         ContainerRNA *cont = cont_;
2752         PropertyRNA *prop;
2753
2754         BLI_assert(default_value == NULL || default_value[0]);
2755
2756         prop = RNA_def_property(cont, identifier, PROP_STRING, PROP_NONE);
2757         if (maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
2758         if (default_value) RNA_def_property_string_default(prop, default_value);
2759         RNA_def_property_ui_text(prop, ui_name, ui_description);
2760
2761         return prop;
2762 }
2763
2764 PropertyRNA *RNA_def_string_file_path(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
2765                                       int maxlen, const char *ui_name, const char *ui_description)
2766 {
2767         ContainerRNA *cont = cont_;
2768         PropertyRNA *prop;
2769
2770         BLI_assert(default_value == NULL || default_value[0]);
2771
2772         prop = RNA_def_property(cont, identifier, PROP_STRING, PROP_FILEPATH);
2773         if (maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
2774         if (default_value) RNA_def_property_string_default(prop, default_value);
2775         RNA_def_property_ui_text(prop, ui_name, ui_description);
2776
2777         return prop;
2778 }
2779
2780 PropertyRNA *RNA_def_string_dir_path(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
2781                                      int maxlen, const char *ui_name, const char *ui_description)
2782 {
2783         ContainerRNA *cont = cont_;
2784         PropertyRNA *prop;
2785
2786         BLI_assert(default_value == NULL || default_value[0]);
2787
2788         prop = RNA_def_property(cont, identifier, PROP_STRING, PROP_DIRPATH);
2789         if (maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
2790         if (default_value) RNA_def_property_string_default(prop, default_value);
2791         RNA_def_property_ui_text(prop, ui_name, ui_description);
2792
2793         return prop;
2794 }
2795
2796 PropertyRNA *RNA_def_string_file_name(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
2797                                       int maxlen, const char *ui_name, const char *ui_description)
2798 {
2799         ContainerRNA *cont = cont_;
2800         PropertyRNA *prop;
2801
2802         BLI_assert(default_value == NULL || default_value[0]);
2803
2804         prop = RNA_def_property(cont, identifier, PROP_STRING, PROP_FILENAME);
2805         if (maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
2806         if (default_value) RNA_def_property_string_default(prop, default_value);
2807         RNA_def_property_ui_text(prop, ui_name, ui_description);
2808
2809         return prop;
2810 }
2811
2812 PropertyRNA *RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items,
2813                           int default_value, const char *ui_name, const char *ui_description)
2814 {
2815         ContainerRNA *cont = cont_;
2816         PropertyRNA *prop;
2817
2818         if (!items) {
2819                 printf("%s: items not allowed to be NULL.\n", __func__);
2820                 return NULL;
2821         }
2822         
2823         prop = RNA_def_property(cont, identifier, PROP_ENUM, PROP_NONE);
2824         if (items) RNA_def_property_enum_items(prop, items);
2825         RNA_def_property_enum_default(prop, default_value);
2826         RNA_def_property_ui_text(prop, ui_name, ui_description);
2827
2828         return prop;
2829 }
2830
2831 /* same as above but sets 'PROP_ENUM_FLAG' before setting the default value */
2832 PropertyRNA *RNA_def_enum_flag(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items,
2833                                int default_value, const char *ui_name, const char *ui_description)
2834 {
2835         ContainerRNA *cont = cont_;
2836         PropertyRNA *prop;
2837
2838         if (!items) {
2839                 printf("%s: items not allowed to be NULL.\n", __func__);
2840                 return NULL;
2841         }
2842
2843         prop = RNA_def_property(cont, identifier, PROP_ENUM, PROP_NONE);
2844         RNA_def_property_flag(prop, PROP_ENUM_FLAG); /* important to run before default set */
2845         if (items) RNA_def_property_enum_items(prop, items);
2846         RNA_def_property_enum_default(prop, default_value);
2847         RNA_def_property_ui_text(prop, ui_name, ui_description);
2848
2849         return prop;
2850 }
2851
2852 void RNA_def_enum_funcs(PropertyRNA *prop, EnumPropertyItemFunc itemfunc)
2853 {
2854         EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
2855         eprop->itemf = itemfunc;
2856 }
2857
2858 PropertyRNA *RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
2859                            float hardmin, float hardmax, const char *ui_name, const char *ui_description,
2860                            float softmin, float softmax)
2861 {
2862         ContainerRNA *cont = cont_;
2863         PropertyRNA *prop;
2864         
2865         ASSERT_SOFT_HARD_LIMITS;
2866
2867         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_NONE);
2868         RNA_def_property_float_default(prop, default_value);
2869         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2870         RNA_def_property_ui_text(prop, ui_name, ui_description);
2871         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2872
2873         return prop;
2874 }
2875
2876 PropertyRNA *RNA_def_float_vector(StructOrFunctionRNA *cont_, const char *identifier, int len,
2877                                   const float *default_value, float hardmin, float hardmax, const char *ui_name,
2878                                   const char *ui_description, float softmin, float softmax)
2879 {
2880         ContainerRNA *cont = cont_;
2881         PropertyRNA *prop;
2882         
2883         ASSERT_SOFT_HARD_LIMITS;
2884
2885         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_XYZ);
2886         if (len != 0) RNA_def_property_array(prop, len);
2887         if (default_value) RNA_def_property_float_array_default(prop, default_value);
2888         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2889         RNA_def_property_ui_text(prop, ui_name, ui_description);
2890         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2891
2892         return prop;
2893 }
2894
2895 PropertyRNA *RNA_def_float_vector_xyz(StructOrFunctionRNA *cont_, const char *identifier, int len,
2896                                       const float *default_value, float hardmin, float hardmax, const char *ui_name,
2897                                       const char *ui_description, float softmin, float softmax)
2898 {
2899         PropertyRNA *prop;
2900         
2901         prop = RNA_def_float_vector(cont_, identifier, len, default_value, hardmin, hardmax, ui_name, ui_description,
2902                                     softmin, softmax);
2903         prop->subtype = PROP_XYZ_LENGTH;
2904
2905         return prop;
2906 }
2907
2908 PropertyRNA *RNA_def_float_color(StructOrFunctionRNA *cont_, const char *identifier, int len,
2909                                  const float *default_value, float hardmin, float hardmax, const char *ui_name,
2910                                  const char *ui_description, float softmin, float softmax)
2911 {
2912         ContainerRNA *cont = cont_;
2913         PropertyRNA *prop;
2914         
2915         ASSERT_SOFT_HARD_LIMITS;
2916
2917         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_COLOR);
2918         if (len != 0) RNA_def_property_array(prop, len);
2919         if (default_value) RNA_def_property_float_array_default(prop, default_value);
2920         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2921         RNA_def_property_ui_text(prop, ui_name, ui_description);
2922         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2923
2924         return prop;
2925 }
2926
2927
2928 PropertyRNA *RNA_def_float_matrix(StructOrFunctionRNA *cont_, const char *identifier, int rows, int columns,
2929                                   const float *default_value, float hardmin, float hardmax, const char *ui_name,
2930                                   const char *ui_description, float softmin, float softmax)
2931 {
2932         ContainerRNA *cont = cont_;
2933         PropertyRNA *prop;
2934         const int length[2] = {rows, columns};
2935
2936         ASSERT_SOFT_HARD_LIMITS;
2937
2938         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_MATRIX);
2939         RNA_def_property_multi_array(prop, 2, length);
2940         if (default_value) RNA_def_property_float_array_default(prop, default_value);
2941         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2942         RNA_def_property_ui_text(prop, ui_name, ui_description);
2943         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2944
2945         return prop;
2946 }
2947
2948 PropertyRNA *RNA_def_float_rotation(StructOrFunctionRNA *cont_, const char *identifier, int len,
2949                                     const float *default_value, float hardmin, float hardmax, const char *ui_name,
2950                                     const char *ui_description, float softmin, float softmax)
2951 {
2952         ContainerRNA *cont = cont_;
2953         PropertyRNA *prop;
2954
2955         ASSERT_SOFT_HARD_LIMITS;
2956
2957         prop = RNA_def_property(cont, identifier, PROP_FLOAT, (len >= 3) ? PROP_EULER : PROP_ANGLE);
2958         if (len != 0) {
2959                 RNA_def_property_array(prop, len);
2960                 if (default_value) RNA_def_property_float_array_default(prop, default_value);
2961         }
2962         else {
2963                 /* RNA_def_property_float_default must be called outside */
2964                 BLI_assert(default_value == NULL);
2965         }
2966         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2967         RNA_def_property_ui_text(prop, ui_name, ui_description);
2968         RNA_def_property_ui_range(prop, softmin, softmax, 10, 3);
2969
2970         return prop;
2971 }
2972
2973 PropertyRNA *RNA_def_float_distance(StructOrFunctionRNA *cont_, const char *identifier,
2974                                     float default_value, float hardmin, float hardmax, const char *ui_name,
2975                                     const char *ui_description, float softmin, float softmax)
2976 {
2977         PropertyRNA *prop = RNA_def_float(cont_, identifier, default_value,
2978                                           hardmin, hardmax, ui_name, ui_description,
2979                                           softmin, softmax);
2980         RNA_def_property_subtype(prop, PROP_DISTANCE);
2981
2982         return prop;
2983 }
2984
2985 PropertyRNA *RNA_def_float_array(StructOrFunctionRNA *cont_, const char *identifier, int len,
2986                                  const float *default_value, float hardmin, float hardmax, const char *ui_name,
2987                                  const char *ui_description, float softmin, float softmax)
2988 {
2989         ContainerRNA *cont = cont_;
2990         PropertyRNA *prop;
2991         
2992         ASSERT_SOFT_HARD_LIMITS;
2993
2994         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_NONE);
2995         if (len != 0) RNA_def_property_array(prop, len);
2996         if (default_value) RNA_def_property_float_array_default(prop, default_value);
2997         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2998         RNA_def_property_ui_text(prop, ui_name, ui_description);
2999         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
3000
3001         return prop;
3002 }
3003
3004 PropertyRNA *RNA_def_float_percentage(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
3005                                       float hardmin, float hardmax, const char *ui_name, const char *ui_description,
3006                                       float softmin, float softmax)
3007 {
3008         ContainerRNA *cont = cont_;
3009         PropertyRNA *prop;
3010         
3011         ASSERT_SOFT_HARD_LIMITS;
3012
3013         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_PERCENTAGE);
3014         RNA_def_property_float_default(prop, default_value);
3015         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
3016         RNA_def_property_ui_text(prop, ui_name, ui_description);
3017         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
3018
3019         return prop;
3020 }
3021
3022 PropertyRNA *RNA_def_float_factor(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
3023                                   float hardmin, float hardmax, const char *ui_name, const char *ui_description,
3024                                   float softmin, float softmax)
3025 {
3026         ContainerRNA *cont = cont_;
3027         PropertyRNA *prop;
3028         
3029         ASSERT_SOFT_HARD_LIMITS;
3030
3031         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_FACTOR);
3032         RNA_def_property_float_default(prop, default_value);
3033         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
3034         RNA_def_property_ui_text(prop, ui_name, ui_description);
3035         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
3036
3037         return prop;
3038 }
3039
3040 PropertyRNA *RNA_def_pointer(StructOrFunctionRNA *cont_, const char *identifier, const char *type,
3041                              const char *ui_name, const char *ui_description)
3042 {
3043         ContainerRNA *cont = cont_;
3044         PropertyRNA *prop;
3045         
3046         prop = RNA_def_property(cont, identifier, PROP_POINTER, PROP_NONE);
3047         RNA_def_property_struct_type(prop, type);
3048         RNA_def_property_ui_text(prop, ui_name, ui_description);
3049
3050         return prop;
3051 }
3052
3053 PropertyRNA *RNA_def_pointer_runtime(StructOrFunctionRNA *cont_, const char *identifier, StructRNA *type,
3054                                      const char *ui_name, const char *ui_description)
3055 {
3056         ContainerRNA *cont = cont_;
3057         PropertyRNA *prop;
3058         
3059         prop = RNA_def_property(cont, identifier, PROP_POINTER, PROP_NONE);
3060         RNA_def_property_struct_runtime(prop, type);
3061         if ((type->flag & STRUCT_ID) != 0) {
3062                 prop->flag |= PROP_EDITABLE;
3063         }
3064         RNA_def_property_ui_text(prop, ui_name, ui_description);
3065
3066         return prop;
3067 }
3068
3069 PropertyRNA *RNA_def_collection(StructOrFunctionRNA *cont_, const char *identifier, const char *type,
3070                                 const char *ui_name, const char *ui_description)
3071 {
3072         ContainerRNA *cont = cont_;
3073         PropertyRNA *prop;
3074         
3075         prop = RNA_def_property(cont, identifier, PROP_COLLECTION, PROP_NONE);
3076         RNA_def_property_struct_type(prop, type);
3077         RNA_def_property_ui_text(prop, ui_name, ui_description);
3078
3079         return prop;
3080 }
3081
3082 PropertyRNA *RNA_def_collection_runtime(StructOrFunctionRNA *cont_, const char *identifier, StructRNA *type,
3083                                         const char *ui_name, const char *ui_description)
3084 {
3085         ContainerRNA *cont = cont_;
3086         PropertyRNA *prop;
3087         
3088         prop = RNA_def_property(cont, identifier, PROP_COLLECTION, PROP_NONE);
3089         RNA_def_property_struct_runtime(prop, type);
3090         RNA_def_property_ui_text(prop, ui_name, ui_description);
3091
3092         return prop;
3093 }
3094
3095 /* Function */
3096
3097 static FunctionRNA *rna_def_function(StructRNA *srna, const char *identifier)
3098 {
3099         FunctionRNA *func;
3100         StructDefRNA *dsrna;
3101         FunctionDefRNA *dfunc;
3102
3103         if (DefRNA.preprocess) {
3104                 char error[512];
3105
3106                 if (rna_validate_identifier(identifier, error, false) == 0) {
3107                         fprintf(stderr, "%s: function identifier \"%s\" - %s\n", __func__, identifier, error);
3108                         DefRNA.error = 1;
3109                 }
3110         }
3111
3112         func = MEM_callocN(sizeof(FunctionRNA), "FunctionRNA");
3113         func->identifier = identifier;
3114         func->description = identifier;
3115
3116         rna_addtail(&srna->functions, func);
3117
3118         if (DefRNA.preprocess) {
3119                 dsrna = rna_find_struct_def(srna);
3120                 dfunc = MEM_callocN(sizeof(FunctionDefRNA), "FunctionDefRNA");
3121                 rna_addtail(&dsrna->functions, dfunc);
3122                 dfunc->func = func;
3123         }
3124         else
3125                 func->flag |= FUNC_RUNTIME;
3126
3127         return func;
3128 }
3129
3130 FunctionRNA *RNA_def_function(StructRNA *srna, const char *identifier, const char *call)
3131 {
3132         FunctionRNA *func;
3133         FunctionDefRNA *dfunc;
3134
3135         if (BLI_findstring_ptr(&srna->functions, identifier, offsetof(FunctionRNA, identifier))) {
3136                 fprintf(stderr, "%s: %s.%s already defined.\n", __func__, srna->identifier, identifier);
3137                 return NULL;
3138         }
3139
3140         func = rna_def_function(srna, identifier);
3141
3142         if (!DefRNA.preprocess) {
3143                 fprintf(stderr, "%s: only at preprocess time.\n", __func__);
3144                 return func;
3145         }
3146
3147         dfunc = rna_find_function_def(func);
3148         dfunc->call = call;
3149
3150         return func;
3151 }
3152
3153 FunctionRNA *RNA_def_function_runtime(StructRNA *srna, const char *identifier, CallFunc call)
3154 {
3155         FunctionRNA *func;
3156
3157         func = rna_def_function(srna, identifier);
3158
3159         if (DefRNA.preprocess) {
3160                 fprintf(stderr, "%s: only at runtime.\n", __func__);
3161                 return func;
3162         }
3163
3164         func->call = call;
3165
3166
3167         return func;
3168 }
3169
3170 /* C return value only!, multiple RNA returns can be done with RNA_def_function_output */
3171 void RNA_def_function_return(FunctionRNA *func, PropertyRNA *ret)
3172 {
3173         if (ret->flag & PROP_DYNAMIC) {
3174                 fprintf(stderr, "%s: \"%s.%s\", dynamic values are not allowed as strict returns, "
3175                         "use RNA_def_function_output instead.\n", __func__, func->identifier, ret->identifier);
3176                 return;
3177         }
3178         else if (ret->arraydimension) {
3179                 fprintf(stderr, "%s: \"%s.%s\", arrays are not allowed as strict returns, "
3180                         "use RNA_def_function_output instead.\n", __func__, func->identifier, ret->identifier);
3181                 return;
3182         }
3183
3184         BLI_assert(func->c_ret == NULL);
3185         func->c_ret = ret;
3186
3187         RNA_def_function_output(func, ret);
3188 }
3189
3190 void RNA_def_function_output(FunctionRNA *UNUSED(func), PropertyRNA *ret)
3191 {
3192         ret->flag_parameter |= PARM_OUTPUT;
3193 }
3194
3195 void RNA_def_function_flag(FunctionRNA *func, int flag)
3196 {
3197         func->flag |= flag;
3198 }
3199
3200 void RNA_def_function_ui_description(FunctionRNA *func, const char *description)
3201 {
3202         func->description = description;
3203 }
3204
3205 int rna_parameter_size(PropertyRNA *parm)
3206 {
3207         PropertyType ptype = parm->type;
3208         int len = parm->totarraylength;
3209
3210         /* XXX in other parts is mentioned that strings can be dynamic as well */
3211         if (parm->flag & PROP_DYNAMIC)
3212                 return sizeof(ParameterDynAlloc);
3213
3214         if (len > 0) {
3215                 switch (ptype) {
3216                         case PROP_BOOLEAN:
3217                         case PROP_INT:
3218                                 return sizeof(int) * len;
3219                         case PROP_FLOAT:
3220                                 return sizeof(float) * len;
3221                         default:
3222                                 break;
3223                 }
3224         }
3225         else {
3226                 switch (ptype) {
3227                         case PROP_BOOLEAN:
3228                         case PROP_INT:
3229                         case PROP_ENUM:
3230                                 return sizeof(int);
3231                         case PROP_FLOAT:
3232                                 return sizeof(float);
3233                         case PROP_STRING: