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