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