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