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