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