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