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