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