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