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