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