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