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