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