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