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