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