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