synched with trunk at revision 31065
[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_idproperties_func(StructRNA *srna, const char *idproperties)
785 {
786         if(!DefRNA.preprocess) {
787                 fprintf(stderr, "RNA_def_struct_idproperties_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_color(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         ContainerRNA *cont= cont_;
2208         PropertyRNA *prop;
2209         
2210         prop= RNA_def_property(cont, identifier, PROP_FLOAT, PROP_COLOR);
2211         if(len != 0) RNA_def_property_array(prop, len);
2212         if(default_value) RNA_def_property_float_array_default(prop, default_value);
2213         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2214         RNA_def_property_ui_text(prop, ui_name, ui_description);
2215         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2216
2217         return prop;
2218 }
2219
2220
2221 PropertyRNA *RNA_def_float_matrix(StructOrFunctionRNA *cont_, const char *identifier, int rows, int columns, const float *default_value, 
2222         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
2223 {
2224         ContainerRNA *cont= cont_;
2225         PropertyRNA *prop;
2226         int length[2]= {rows, columns};
2227         
2228         prop= RNA_def_property(cont, identifier, PROP_FLOAT, PROP_MATRIX);
2229         RNA_def_property_multi_array(prop, 2, length);
2230         if(default_value) RNA_def_property_float_array_default(prop, default_value);
2231         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2232         RNA_def_property_ui_text(prop, ui_name, ui_description);
2233         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2234
2235         return prop;
2236 }
2237
2238 PropertyRNA *RNA_def_float_rotation(StructOrFunctionRNA *cont_, const char *identifier, int len, const float *default_value,
2239         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
2240 {
2241         ContainerRNA *cont= cont_;
2242         PropertyRNA *prop;
2243         
2244         prop= RNA_def_property(cont, identifier, PROP_FLOAT, PROP_EULER); // XXX
2245         if(len != 0) RNA_def_property_array(prop, len);
2246         if(default_value) RNA_def_property_float_array_default(prop, default_value);
2247         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2248         RNA_def_property_ui_text(prop, ui_name, ui_description);
2249         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2250
2251         return prop;
2252 }
2253
2254 PropertyRNA *RNA_def_float_array(StructOrFunctionRNA *cont_, const char *identifier, int len, const float *default_value,
2255         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
2256 {
2257         ContainerRNA *cont= cont_;
2258         PropertyRNA *prop;
2259         
2260         prop= RNA_def_property(cont, identifier, PROP_FLOAT, PROP_NONE);
2261         if(len != 0) RNA_def_property_array(prop, len);
2262         if(default_value) RNA_def_property_float_array_default(prop, default_value);
2263         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2264         RNA_def_property_ui_text(prop, ui_name, ui_description);
2265         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2266
2267         return prop;
2268 }
2269
2270 PropertyRNA *RNA_def_float_percentage(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
2271         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
2272 {
2273         ContainerRNA *cont= cont_;
2274         PropertyRNA *prop;
2275         
2276         prop= RNA_def_property(cont, identifier, PROP_FLOAT, PROP_PERCENTAGE);
2277         RNA_def_property_float_default(prop, default_value);
2278         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2279         RNA_def_property_ui_text(prop, ui_name, ui_description);
2280         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2281
2282         return prop;
2283 }
2284
2285 PropertyRNA *RNA_def_float_factor(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
2286         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
2287 {
2288         ContainerRNA *cont= cont_;
2289         PropertyRNA *prop;
2290         
2291         prop= RNA_def_property(cont, identifier, PROP_FLOAT, PROP_FACTOR);
2292         RNA_def_property_float_default(prop, default_value);
2293         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2294         RNA_def_property_ui_text(prop, ui_name, ui_description);
2295         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2296
2297         return prop;
2298 }
2299
2300 PropertyRNA *RNA_def_pointer(StructOrFunctionRNA *cont_, const char *identifier, const char *type,
2301         const char *ui_name, const char *ui_description)
2302 {
2303         ContainerRNA *cont= cont_;
2304         PropertyRNA *prop;
2305         
2306         prop= RNA_def_property(cont, identifier, PROP_POINTER, PROP_NONE);
2307         RNA_def_property_struct_type(prop, type);
2308         RNA_def_property_ui_text(prop, ui_name, ui_description);
2309
2310         return prop;
2311 }
2312
2313 PropertyRNA *RNA_def_pointer_runtime(StructOrFunctionRNA *cont_, const char *identifier, StructRNA *type,
2314         const char *ui_name, const char *ui_description)
2315 {
2316         ContainerRNA *cont= cont_;
2317         PropertyRNA *prop;
2318         
2319         prop= RNA_def_property(cont, identifier, PROP_POINTER, PROP_NONE);
2320         RNA_def_property_struct_runtime(prop, type);
2321         RNA_def_property_ui_text(prop, ui_name, ui_description);
2322
2323         return prop;
2324 }
2325
2326 PropertyRNA *RNA_def_collection(StructOrFunctionRNA *cont_, const char *identifier, const char *type,
2327         const char *ui_name, const char *ui_description)
2328 {
2329         ContainerRNA *cont= cont_;
2330         PropertyRNA *prop;
2331         
2332         prop= RNA_def_property(cont, identifier, PROP_COLLECTION, PROP_NONE);
2333         RNA_def_property_struct_type(prop, type);
2334         RNA_def_property_ui_text(prop, ui_name, ui_description);
2335
2336         return prop;
2337 }
2338
2339 PropertyRNA *RNA_def_collection_runtime(StructOrFunctionRNA *cont_, const char *identifier, StructRNA *type,
2340         const char *ui_name, const char *ui_description)
2341 {
2342         ContainerRNA *cont= cont_;
2343         PropertyRNA *prop;
2344         
2345         prop= RNA_def_property(cont, identifier, PROP_COLLECTION, PROP_NONE);
2346         RNA_def_property_struct_runtime(prop, type);
2347         RNA_def_property_ui_text(prop, ui_name, ui_description);
2348
2349         return prop;
2350 }
2351
2352 /* Function */
2353
2354 static FunctionRNA *rna_def_function(StructRNA *srna, const char *identifier)
2355 {
2356         FunctionRNA *func;
2357         StructDefRNA *dsrna;
2358         FunctionDefRNA *dfunc;
2359
2360         if(DefRNA.preprocess) {
2361                 char error[512];
2362
2363                 if (rna_validate_identifier(identifier, error, 0) == 0) {
2364                         fprintf(stderr, "RNA_def_function: function identifier \"%s\" - %s\n", identifier, error);
2365                         DefRNA.error= 1;
2366                 }
2367         }
2368
2369         func= MEM_callocN(sizeof(FunctionRNA), "FunctionRNA");
2370         func->identifier= identifier;
2371         func->description= identifier;
2372
2373         rna_addtail(&srna->functions, func);
2374
2375         if(DefRNA.preprocess) {
2376                 dsrna= rna_find_struct_def(srna);
2377                 dfunc= MEM_callocN(sizeof(FunctionDefRNA), "FunctionDefRNA");
2378                 rna_addtail(&dsrna->functions, dfunc);
2379                 dfunc->func= func;
2380         }
2381         else
2382                 func->flag|= FUNC_RUNTIME;
2383
2384         return func;
2385 }
2386
2387 FunctionRNA *RNA_def_function(StructRNA *srna, const char *identifier, const char *call)
2388 {
2389         FunctionRNA *func;
2390         FunctionDefRNA *dfunc;
2391
2392         func= rna_def_function(srna, identifier);
2393
2394         if(!DefRNA.preprocess) {
2395                 fprintf(stderr, "RNA_def_function: only at preprocess time.\n");
2396                 return func;
2397         }
2398
2399         dfunc= rna_find_function_def(func);
2400         dfunc->call= call;
2401
2402         return func;
2403 }
2404
2405 FunctionRNA *RNA_def_function_runtime(StructRNA *srna, const char *identifier, CallFunc call)
2406 {
2407         FunctionRNA *func;
2408
2409         func= rna_def_function(srna, identifier);
2410
2411         if(DefRNA.preprocess) {
2412                 fprintf(stderr, "RNA_def_function_call_runtime: only at runtime.\n");
2413                 return func;
2414         }
2415
2416         func->call= call;
2417
2418
2419         return func;
2420 }
2421
2422 /* C return value only!, multiple RNA returns can be done with RNA_def_function_output */
2423 void RNA_def_function_return(FunctionRNA *func, PropertyRNA *ret)
2424 {
2425         if (ret->flag & PROP_DYNAMIC) {
2426                 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);
2427                 return;
2428         }
2429         else if (ret->arraydimension) {
2430                 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);
2431                 return;
2432         }
2433
2434         func->c_ret= ret;
2435
2436         RNA_def_function_output(func, ret);
2437 }
2438
2439 void RNA_def_function_output(FunctionRNA *func, PropertyRNA *ret)
2440 {
2441         ret->flag|= PROP_OUTPUT;
2442 }
2443
2444 void RNA_def_function_flag(FunctionRNA *func, int flag)
2445 {
2446         func->flag|= flag;
2447 }
2448
2449 void RNA_def_function_ui_description(FunctionRNA *func, const char *description)
2450 {
2451         func->description= description;
2452 }
2453
2454 int rna_parameter_size(PropertyRNA *parm)
2455 {
2456         PropertyType ptype= parm->type;
2457         int len= parm->totarraylength; /* only supports fixed length at the moment */
2458
2459         if(len > 0) {
2460                 /* XXX in other parts is mentioned that strings can be dynamic as well */
2461                 if (parm->flag & PROP_DYNAMIC)
2462                         return sizeof(void *);
2463
2464                 switch (ptype) {
2465                         case PROP_BOOLEAN:
2466                         case PROP_INT:
2467                                 return sizeof(int)*len;
2468                         case PROP_FLOAT:
2469                                 return sizeof(float)*len;
2470                         default:
2471                                 break;
2472                 }
2473         }
2474         else {
2475                 switch (ptype) {
2476                         case PROP_BOOLEAN:
2477                         case PROP_INT:
2478                         case PROP_ENUM:
2479                                 return sizeof(int);
2480                         case PROP_FLOAT:
2481                                 return sizeof(float);
2482                         case PROP_STRING:
2483                                 /* return  valyes dont store a pointer to the original */
2484                                 if(parm->flag & PROP_THICK_WRAP) {
2485                                         StringPropertyRNA *sparm= (StringPropertyRNA*)parm;
2486                                         return sizeof(char) * sparm->maxlength;
2487                                 } else
2488                                         return sizeof(char *);
2489                         case PROP_POINTER: {
2490 #ifdef RNA_RUNTIME
2491                                 if(parm->flag & PROP_RNAPTR)
2492                                         return sizeof(PointerRNA);
2493                                 else
2494                                         return sizeof(void *);
2495 #else
2496                                 if(parm->flag & PROP_RNAPTR)
2497                                         return sizeof(PointerRNA);
2498                                 else
2499                                         return sizeof(void *);
2500 #endif
2501                         }
2502                         case PROP_COLLECTION:
2503                                 return sizeof(ListBase);
2504                 }
2505         }
2506
2507         return sizeof(void *);
2508 }
2509
2510 /* this function returns the size of the memory allocated for the parameter,
2511    useful for instance for memory alignment or for storing additional information */
2512 int rna_parameter_size_alloc(PropertyRNA *parm)
2513 {
2514         int size = rna_parameter_size(parm);
2515
2516         if (parm->flag & PROP_DYNAMIC)
2517                 size+= sizeof(int);
2518
2519         return size;
2520 }
2521
2522 /* Dynamic Enums */
2523
2524 void RNA_enum_item_add(EnumPropertyItem **items, int *totitem, EnumPropertyItem *item)
2525 {
2526         EnumPropertyItem *newitems;
2527         int tot= *totitem;
2528
2529         if(tot == 0) {
2530                 *items= MEM_callocN(sizeof(EnumPropertyItem)*8, "RNA_enum_items_add");
2531         }
2532         else if(tot >= 8 && (tot&(tot-1)) == 0){
2533                 /* power of two > 8 */
2534                 newitems= MEM_callocN(sizeof(EnumPropertyItem)*tot*2, "RNA_enum_items_add");
2535                 memcpy(newitems, *items, sizeof(EnumPropertyItem)*tot);
2536                 MEM_freeN(*items);
2537                 *items= newitems;
2538         }
2539
2540         (*items)[tot]= *item;
2541         *totitem= tot+1;
2542 }
2543
2544 void RNA_enum_item_add_separator(EnumPropertyItem **items, int *totitem)
2545 {
2546         static EnumPropertyItem sepr = {0, "", 0, NULL, NULL};
2547         RNA_enum_item_add(items, totitem, &sepr);
2548 }
2549
2550 void RNA_enum_items_add(EnumPropertyItem **items, int *totitem, EnumPropertyItem *item)
2551 {
2552         for(; item->identifier; item++)
2553                 RNA_enum_item_add(items, totitem, item);
2554 }
2555
2556 void RNA_enum_items_add_value(EnumPropertyItem **items, int *totitem, EnumPropertyItem *item, int value)
2557 {
2558         for(; item->identifier; item++) {
2559                 if(item->value == value) {
2560                         RNA_enum_item_add(items, totitem, item);
2561                         break; // break on first match - does this break anything? (is quick hack to get object->parent_type working ok for armature/lattice)
2562                 }
2563         }
2564 }
2565
2566 void RNA_enum_item_end(EnumPropertyItem **items, int *totitem)
2567 {
2568         static EnumPropertyItem empty = {0, NULL, 0, NULL, NULL};
2569         RNA_enum_item_add(items, totitem, &empty);
2570 }
2571
2572 /* Memory management */
2573
2574 #ifdef RNA_RUNTIME
2575 void RNA_def_struct_duplicate_pointers(StructRNA *srna)
2576 {
2577         if(srna->identifier) srna->identifier= BLI_strdup(srna->identifier);
2578         if(srna->name) srna->name= BLI_strdup(srna->name);
2579         if(srna->description) srna->description= BLI_strdup(srna->description);
2580
2581         srna->flag |= STRUCT_FREE_POINTERS;
2582 }
2583
2584 void RNA_def_struct_free_pointers(StructRNA *srna)
2585 {
2586         if(srna->flag & STRUCT_FREE_POINTERS) {
2587                 if(srna->identifier) MEM_freeN((void*)srna->identifier);
2588                 if(srna->name) MEM_freeN((void*)srna->name);
2589                 if(srna->description) MEM_freeN((void*)srna->description);
2590         }
2591 }
2592
2593 void RNA_def_func_duplicate_pointers(FunctionRNA *func)
2594 {
2595         if(func->identifier) func->identifier= BLI_strdup(func->identifier);
2596         if(func->description) func->description= BLI_strdup(func->description);
2597
2598         func->flag |= FUNC_FREE_POINTERS;
2599 }
2600
2601 void RNA_def_func_free_pointers(FunctionRNA *func)
2602 {
2603         if(func->flag & FUNC_FREE_POINTERS) {
2604                 if(func->identifier) MEM_freeN((void*)func->identifier);
2605                 if(func->description) MEM_freeN((void*)func->description);
2606         }
2607 }
2608
2609 void RNA_def_property_duplicate_pointers(PropertyRNA *prop)
2610 {
2611         EnumPropertyItem *earray;
2612         float *farray;
2613         int *iarray;
2614         int a;
2615
2616         if(prop->identifier) prop->identifier= BLI_strdup(prop->identifier);
2617         if(prop->name) prop->name= BLI_strdup(prop->name);
2618         if(prop->description) prop->description= BLI_strdup(prop->description);
2619
2620         switch(prop->type) {
2621                 case PROP_BOOLEAN: {
2622                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
2623
2624                         if(bprop->defaultarray) {
2625                                 iarray= MEM_callocN(sizeof(int)*prop->totarraylength, "RNA_def_property_store");
2626                                 memcpy(iarray, bprop->defaultarray, sizeof(int)*prop->totarraylength);
2627                                 bprop->defaultarray= iarray;
2628                         }
2629                         break;
2630                 }
2631                 case PROP_INT: {
2632                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
2633
2634                         if(iprop->defaultarray) {
2635                                 iarray= MEM_callocN(sizeof(int)*prop->totarraylength, "RNA_def_property_store");
2636                                 memcpy(iarray, iprop->defaultarray, sizeof(int)*prop->totarraylength);
2637                                 iprop->defaultarray= iarray;
2638                         }
2639                         break;
2640                 }
2641                 case PROP_ENUM: {
2642                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
2643
2644                         if(eprop->item) {
2645                                 earray= MEM_callocN(sizeof(EnumPropertyItem)*(eprop->totitem+1), "RNA_def_property_store"),
2646                                 memcpy(earray, eprop->item, sizeof(EnumPropertyItem)*(eprop->totitem+1));
2647                                 eprop->item= earray;
2648
2649                                 for(a=0; a<eprop->totitem; a++) {
2650                                         if(eprop->item[a].identifier) eprop->item[a].identifier= BLI_strdup(eprop->item[a].identifier);
2651                                         if(eprop->item[a].name) eprop->item[a].name= BLI_strdup(eprop->item[a].name);
2652                                         if(eprop->item[a].description) eprop->item[a].description= BLI_strdup(eprop->item[a].description);
2653                                 }
2654                         }
2655                         break;
2656                 }
2657                 case PROP_FLOAT: {
2658                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
2659
2660                         if(fprop->defaultarray) {
2661                                 farray= MEM_callocN(sizeof(float)*prop->totarraylength, "RNA_def_property_store");
2662                                 memcpy(farray, fprop->defaultarray, sizeof(float)*prop->totarraylength);
2663                                 fprop->defaultarray= farray;
2664                         }
2665                         break;
2666                 }
2667                 case PROP_STRING: {
2668                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
2669                         if(sprop->defaultvalue) sprop->defaultvalue= BLI_strdup(sprop->defaultvalue);
2670                         break;
2671                 }
2672                 default:
2673                         break;
2674         }
2675
2676         prop->flag |= PROP_FREE_POINTERS;
2677 }
2678
2679 void RNA_def_property_free_pointers(PropertyRNA *prop)
2680 {
2681         if(prop->flag & PROP_FREE_POINTERS) {
2682                 int a;
2683
2684                 if(prop->identifier) MEM_freeN((void*)prop->identifier);
2685                 if(prop->name) MEM_freeN((void*)prop->name);
2686                 if(prop->description) MEM_freeN((void*)prop->description);
2687
2688                 switch(prop->type) {
2689                         case PROP_BOOLEAN: {
2690                                 BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
2691                                 if(bprop->defaultarray) MEM_freeN((void*)bprop->defaultarray);
2692                                 break;
2693                         }
2694                         case PROP_INT: {
2695                                 IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
2696                                 if(iprop->defaultarray) MEM_freeN((void*)iprop->defaultarray);
2697                                 break;
2698                         }
2699                         case PROP_FLOAT: {
2700                                 FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
2701                                 if(fprop->defaultarray) MEM_freeN((void*)fprop->defaultarray);
2702                                 break;
2703                         }
2704                         case PROP_ENUM: {
2705                                 EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
2706
2707                                 for(a=0; a<eprop->totitem; a++) {
2708                                         if(eprop->item[a].identifier) MEM_freeN((void*)eprop->item[a].identifier);
2709                                         if(eprop->item[a].name) MEM_freeN((void*)eprop->item[a].name);
2710                                         if(eprop->item[a].description) MEM_freeN((void*)eprop->item[a].description);
2711                                 }
2712
2713                                 if(eprop->item) MEM_freeN((void*)eprop->item);
2714                                 break;
2715                         }
2716                         case PROP_STRING: {
2717                                 StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
2718                                 if(sprop->defaultvalue) MEM_freeN((void*)sprop->defaultvalue);
2719                                 break;
2720                         }
2721                         default:
2722                                 break;
2723                 }
2724         }
2725 }
2726
2727 void RNA_def_property_free(StructOrFunctionRNA *cont_, PropertyRNA *prop)
2728 {
2729         ContainerRNA *cont= cont_;
2730         
2731         RNA_def_property_free_pointers(prop);
2732         
2733         if(prop->flag & PROP_RUNTIME) {
2734                 if(cont->prophash)
2735                         BLI_ghash_remove(cont->prophash, (void*)prop->identifier, NULL, NULL);
2736
2737                 rna_freelinkN(&cont->properties, prop);
2738         }
2739 }
2740
2741 /* note: only intended for removing dynamic props */
2742 int RNA_def_property_free_identifier(StructOrFunctionRNA *cont_, const char *identifier)
2743 {
2744         ContainerRNA *cont= cont_;
2745         PropertyRNA *prop;
2746         
2747         for(prop= cont->properties.first; prop; prop= prop->next) {
2748                 if(strcmp(prop->identifier, identifier)==0) {
2749                         if(prop->flag & PROP_RUNTIME) {
2750                                 RNA_def_property_free(cont_, prop);
2751                                 return 1;
2752                         }
2753                         else {
2754                                 return -1;
2755                         }
2756                 }
2757         }
2758         return 0;
2759 }
2760 #endif
2761