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