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