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