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