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