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