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