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