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