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