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