Merging r46203 through r46413 from trunk into soc-2011-tomato
[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/py3k/reference/lexical_analysis.html#keywords */
380         static const char *kwlist[] = {
381                 /* "False", "None", "True", */
382                 "and", "as", "assert", "break",
383                 "class", "continue", "def", "del", "elif", "else", "except",
384                 "finally", "for", "from", "global", "if", "import", "in",
385                 "is", "lambda", "nonlocal", "not", "or", "pass", "raise",
386                 "return", "try", "while", "with", "yield", NULL
387         };
388         
389         
390         if (!isalpha(identifier[0])) {
391                 strcpy(error, "first character failed isalpha() check");
392                 return 0;
393         }
394         
395         for (a = 0; identifier[a]; a++) {
396                 if (DefRNA.preprocess && property) {
397                         if (isalpha(identifier[a]) && isupper(identifier[a])) {
398                                 strcpy(error, "property names must contain lower case characters only");
399                                 return 0;
400                         }
401                 }
402                 
403                 if (identifier[a] =='_') {
404                         continue;
405                 }
406
407                 if (identifier[a] ==' ') {
408                         strcpy(error, "spaces are not okay in identifier names");
409                         return 0;
410                 }
411
412                 if (isalnum(identifier[a]) == 0) {
413                         strcpy(error, "one of the characters failed an isalnum() check and is not an underscore");
414                         return 0;
415                 }
416         }
417         
418         for (a = 0; kwlist[a]; a++) {
419                 if (strcmp(identifier, kwlist[a]) == 0) {
420                         strcpy(error, "this keyword is reserved by python");
421                         return 0;
422                 }
423         }
424
425         if (property) {
426                 static const char *kwlist_prop[] = {
427                         /* not keywords but reserved all the same because py uses */
428                         "keys", "values", "items", "get",
429                         NULL
430                 };
431
432                 for (a = 0; kwlist_prop[a]; a++) {
433                         if (strcmp(identifier, kwlist_prop[a]) == 0) {
434                                 strcpy(error, "this keyword is reserved by python");
435                                 return 0;
436                         }
437                 }
438         }
439         
440         return 1;
441 }
442
443 /* Blender Data Definition */
444
445 BlenderRNA *RNA_create(void)
446 {
447         BlenderRNA *brna;
448
449         brna = MEM_callocN(sizeof(BlenderRNA), "BlenderRNA");
450
451         DefRNA.sdna = DNA_sdna_from_data(DNAstr,  DNAlen, 0);
452         DefRNA.structs.first = DefRNA.structs.last = NULL;
453         DefRNA.error = 0;
454         DefRNA.preprocess = 1;
455
456         return brna;
457 }
458
459 void RNA_define_free(BlenderRNA *UNUSED(brna))
460 {
461         StructDefRNA *ds;
462         FunctionDefRNA *dfunc;
463         AllocDefRNA *alloc;
464
465         for (alloc = DefRNA.allocs.first; alloc; alloc = alloc->next)
466                 MEM_freeN(alloc->mem);
467         rna_freelistN(&DefRNA.allocs);
468
469         for (ds = DefRNA.structs.first; ds; ds = ds->cont.next) {
470                 for (dfunc = ds->functions.first; dfunc; dfunc = dfunc->cont.next)
471                         rna_freelistN(&dfunc->cont.properties);
472
473                 rna_freelistN(&ds->cont.properties);
474                 rna_freelistN(&ds->functions);
475         }
476
477         rna_freelistN(&DefRNA.structs);
478
479         if (DefRNA.sdna) {
480                 DNA_sdna_free(DefRNA.sdna);
481                 DefRNA.sdna = NULL;
482         }
483
484         DefRNA.error = 0;
485 }
486
487 void RNA_define_verify_sdna(int verify)
488 {
489         DefRNA.verify = verify;
490 }
491
492 void RNA_struct_free_extension(StructRNA *srna, ExtensionRNA *ext)
493 {
494 #ifdef RNA_RUNTIME
495         ext->free(ext->data);                   /* decref's the PyObject that the srna owns */
496         RNA_struct_blender_type_set(srna, NULL); /* this gets accessed again - XXX fixme */
497         RNA_struct_py_type_set(srna, NULL);     /* NULL the srna's value so RNA_struct_free wont complain of a leak */
498 #endif
499 }
500
501 void RNA_struct_free(BlenderRNA *brna, StructRNA *srna)
502 {
503 #ifdef RNA_RUNTIME
504         FunctionRNA *func, *nextfunc;
505         PropertyRNA *prop, *nextprop;
506         PropertyRNA *parm, *nextparm;
507
508         /*
509         if (srna->flag & STRUCT_RUNTIME) {
510                 if (RNA_struct_py_type_get(srna)) {
511                         fprintf(stderr, "%s '%s' freed while holding a python reference\n", __func__, srna->identifier);
512                 }
513         } */
514
515         for (prop = srna->cont.properties.first; prop; prop = nextprop) {
516                 nextprop = prop->next;
517
518                 RNA_def_property_free_pointers(prop);
519
520                 if (prop->flag & PROP_RUNTIME)
521                         rna_freelinkN(&srna->cont.properties, prop);
522         }
523
524         for (func = srna->functions.first; func; func = nextfunc) {
525                 nextfunc = func->cont.next;
526
527                 for (parm = func->cont.properties.first; parm; parm = nextparm) {
528                         nextparm = parm->next;
529
530                         RNA_def_property_free_pointers(parm);
531
532                         if (parm->flag & PROP_RUNTIME)
533                                 rna_freelinkN(&func->cont.properties, parm);
534                 }
535
536                 RNA_def_func_free_pointers(func);
537
538                 if (func->flag & FUNC_RUNTIME)
539                         rna_freelinkN(&srna->functions, func);
540         }
541
542         RNA_def_struct_free_pointers(srna);
543
544         if (srna->flag & STRUCT_RUNTIME)
545                 rna_freelinkN(&brna->structs, srna);
546
547 #endif
548 }
549
550 void RNA_free(BlenderRNA *brna)
551 {
552         StructRNA *srna, *nextsrna;
553         FunctionRNA *func;
554
555         if (DefRNA.preprocess) {
556                 RNA_define_free(brna);
557
558                 for (srna = brna->structs.first; srna; srna = srna->cont.next) {
559                         for (func = srna->functions.first; func; func = func->cont.next)
560                                 rna_freelistN(&func->cont.properties);
561
562                         rna_freelistN(&srna->cont.properties);
563                         rna_freelistN(&srna->functions);
564                 }
565
566                 rna_freelistN(&brna->structs);
567                 
568                 MEM_freeN(brna);
569         }
570         else {
571                 for (srna = brna->structs.first; srna; srna = nextsrna) {
572                         nextsrna = srna->cont.next;
573                         RNA_struct_free(brna, srna);
574                 }
575         }
576 }
577
578 static size_t rna_property_type_sizeof(PropertyType type)
579 {
580         switch (type) {
581                 case PROP_BOOLEAN: return sizeof(BoolPropertyRNA);
582                 case PROP_INT: return sizeof(IntPropertyRNA);
583                 case PROP_FLOAT: return sizeof(FloatPropertyRNA);
584                 case PROP_STRING: return sizeof(StringPropertyRNA);
585                 case PROP_ENUM: return sizeof(EnumPropertyRNA);
586                 case PROP_POINTER: return sizeof(PointerPropertyRNA);
587                 case PROP_COLLECTION: return sizeof(CollectionPropertyRNA);
588                 default: return 0;
589         }
590 }
591
592 static StructDefRNA *rna_find_def_struct(StructRNA *srna)
593 {
594         StructDefRNA *ds;
595
596         for (ds = DefRNA.structs.first; ds; ds = ds->cont.next)
597                 if (ds->srna == srna)
598                         return ds;
599
600         return NULL;
601 }
602
603 /* Struct Definition */
604
605 StructRNA *RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *from)
606 {
607         StructRNA *srna, *srnafrom = NULL;
608         StructDefRNA *ds = NULL, *dsfrom = NULL;
609         PropertyRNA *prop;
610         
611         if (DefRNA.preprocess) {
612                 char error[512];
613
614                 if (rna_validate_identifier(identifier, error, 0) == 0) {
615                         fprintf(stderr, "%s: struct identifier \"%s\" error - %s\n", __func__, identifier, error);
616                         DefRNA.error = 1;
617                 }
618         }
619         
620         if (from) {
621                 /* find struct to derive from */
622                 for (srnafrom = brna->structs.first; srnafrom; srnafrom = srnafrom->cont.next)
623                         if (strcmp(srnafrom->identifier, from) == 0)
624                                 break;
625
626                 if (!srnafrom) {
627                         fprintf(stderr, "%s: struct %s not found to define %s.\n", __func__, from, identifier);
628                         DefRNA.error = 1;
629                 }
630         }
631
632         srna = MEM_callocN(sizeof(StructRNA), "StructRNA");
633         DefRNA.laststruct = srna;
634
635         if (srnafrom) {
636                 /* copy from struct to derive stuff, a bit clumsy since we can't
637                  * use MEM_dupallocN, data structs may not be alloced but builtin */
638                 memcpy(srna, srnafrom, sizeof(StructRNA));
639                 srna->cont.prophash = NULL;
640                 srna->cont.properties.first = srna->cont.properties.last = NULL;
641                 srna->functions.first = srna->functions.last = NULL;
642                 srna->py_type = NULL;
643
644                 if (DefRNA.preprocess) {
645                         srna->base = srnafrom;
646                         dsfrom = rna_find_def_struct(srnafrom);
647                 }
648                 else
649                         srna->base = srnafrom;
650         }
651         
652         srna->identifier = identifier;
653         srna->name = identifier; /* may be overwritten later RNA_def_struct_ui_text */
654         srna->description = "";
655         srna->flag |= STRUCT_UNDO;
656         if (!srnafrom)
657                 srna->icon = ICON_DOT;
658
659         rna_addtail(&brna->structs, srna);
660
661         if (DefRNA.preprocess) {
662                 ds = MEM_callocN(sizeof(StructDefRNA), "StructDefRNA");
663                 ds->srna = srna;
664                 rna_addtail(&DefRNA.structs, ds);
665
666                 if (dsfrom)
667                         ds->dnafromname = dsfrom->dnaname;
668         }
669
670         /* in preprocess, try to find sdna */
671         if (DefRNA.preprocess)
672                 RNA_def_struct_sdna(srna, srna->identifier);
673         else
674                 srna->flag |= STRUCT_RUNTIME;
675
676         if (srnafrom) {
677                 srna->nameproperty = srnafrom->nameproperty;
678                 srna->iteratorproperty = srnafrom->iteratorproperty;
679         }
680         else {
681                 /* define some builtin properties */
682                 prop = RNA_def_property(&srna->cont, "rna_properties", PROP_COLLECTION, PROP_NONE);
683                 RNA_def_property_flag(prop, PROP_BUILTIN);
684                 RNA_def_property_ui_text(prop, "Properties", "RNA property collection");
685
686                 if (DefRNA.preprocess) {
687                         RNA_def_property_struct_type(prop, "Property");
688                         RNA_def_property_collection_funcs(prop, "rna_builtin_properties_begin", "rna_builtin_properties_next",
689                                                           "rna_iterator_listbase_end", "rna_builtin_properties_get", NULL, NULL,
690                                                           "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 void RNA_def_struct_translation_context(StructRNA *srna, const char *context)
875 {
876         srna->translation_context = context;
877 }
878
879 /* Property Definition */
880
881 PropertyRNA *RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier, int type, int subtype)
882 {
883         /*StructRNA *srna= DefRNA.laststruct;*/ /* invalid for python defined props */
884         ContainerRNA *cont = cont_;
885         ContainerDefRNA *dcont;
886         PropertyDefRNA *dprop = NULL;
887         PropertyRNA *prop;
888
889         if (DefRNA.preprocess) {
890                 char error[512];
891                 
892                 if (rna_validate_identifier(identifier, error, 1) == 0) {
893                         fprintf(stderr, "%s: property identifier \"%s.%s\" - %s\n", __func__,
894                                 CONTAINER_RNA_ID(cont), identifier, error);
895                         DefRNA.error = 1;
896                 }
897                 
898                 dcont = rna_find_container_def(cont);
899
900                 /* XXX - toto, detect supertype collisions */
901                 if (rna_findlink(&dcont->properties, identifier)) {
902                         fprintf(stderr, "%s: duplicate identifier \"%s.%s\"\n", __func__, CONTAINER_RNA_ID(cont), identifier);
903                         DefRNA.error = 1;
904                 }
905
906                 dprop = MEM_callocN(sizeof(PropertyDefRNA), "PropertyDefRNA");
907                 rna_addtail(&dcont->properties, dprop);
908         }
909
910         prop = MEM_callocN(rna_property_type_sizeof(type), "PropertyRNA");
911
912         switch (type) {
913                 case PROP_BOOLEAN:
914                         if (DefRNA.preprocess) {
915                                 if ((subtype & ~(PROP_LAYER_MEMBER)) != PROP_NONE) {
916                                         fprintf(stderr, "%s: subtype does not apply to 'PROP_BOOLEAN' \"%s.%s\"\n", __func__,
917                                                 CONTAINER_RNA_ID(cont), identifier);
918                                         DefRNA.error = 1;
919                                 }
920                         }
921                         break;
922                 case PROP_INT: {
923                         IntPropertyRNA *iprop = (IntPropertyRNA*)prop;
924
925                         iprop->hardmin = (subtype == PROP_UNSIGNED)? 0: INT_MIN;
926                         iprop->hardmax = INT_MAX;
927
928                         iprop->softmin = (subtype == PROP_UNSIGNED)? 0: -10000; /* rather arbitrary .. */
929                         iprop->softmax = 10000;
930                         iprop->step = 1;
931                         break;
932                 }
933                 case PROP_FLOAT: {
934                         FloatPropertyRNA *fprop = (FloatPropertyRNA*)prop;
935
936                         fprop->hardmin = (subtype == PROP_UNSIGNED)? 0.0f: -FLT_MAX;
937                         fprop->hardmax = FLT_MAX;
938
939                         if (ELEM(subtype, PROP_COLOR, PROP_COLOR_GAMMA)) {
940                                 fprop->softmin = 0.0f;
941                                 fprop->softmax = 1.0f;
942                         }
943                         else if (subtype == PROP_FACTOR) {
944                                 fprop->softmin = fprop->hardmin = 0.0f;
945                                 fprop->softmax = fprop->hardmax = 1.0f;
946                         }
947                         else {
948                                 fprop->softmin = (subtype == PROP_UNSIGNED)? 0.0f: -10000.0f; /* rather arbitrary .. */
949                                 fprop->softmax = 10000.0f;
950                         }
951                         fprop->step = 10;
952                         fprop->precision = 3;
953                         break;
954                 }
955                 case PROP_STRING: {
956                         StringPropertyRNA *sprop = (StringPropertyRNA*)prop;
957
958                         sprop->defaultvalue = "";
959                         break;
960                 }
961                 case PROP_ENUM:
962                 case PROP_POINTER:
963                 case PROP_COLLECTION:
964                         break;
965                 default:
966                         fprintf(stderr, "%s: \"%s.%s\", invalid property type.\n", __func__, CONTAINER_RNA_ID(cont), identifier);
967                         DefRNA.error = 1;
968                         return NULL;
969         }
970
971         if (DefRNA.preprocess) {
972                 dprop->cont = cont;
973                 dprop->prop = prop;
974         }
975
976         prop->magic = RNA_MAGIC;
977         prop->identifier = identifier;
978         prop->type = type;
979         prop->subtype = subtype;
980         prop->name = identifier;
981         prop->description = "";
982         /* a priori not raw editable */
983         prop->rawtype = -1;
984
985         if (type != PROP_COLLECTION && type != PROP_POINTER) {
986                 prop->flag = PROP_EDITABLE;
987         
988                 if (type != PROP_STRING)
989                         prop->flag |= PROP_ANIMATABLE;
990         }
991
992         if (type == PROP_STRING) {
993                 /* used so generated 'get/length/set' functions skip a NULL check
994                  * in some cases we want it */
995                 RNA_def_property_flag(prop, PROP_NEVER_NULL);
996         }
997
998         if (DefRNA.preprocess) {
999                 switch (type) {
1000                         case PROP_BOOLEAN:
1001                                 DefRNA.silent = 1;
1002                                 RNA_def_property_boolean_sdna(prop, NULL, identifier, 0);
1003                                 DefRNA.silent = 0;
1004                                 break;
1005                         case PROP_INT: {
1006                                 DefRNA.silent = 1;
1007                                 RNA_def_property_int_sdna(prop, NULL, identifier);
1008                                 DefRNA.silent = 0;
1009                                 break;
1010                         }
1011                         case PROP_FLOAT: {
1012                                 DefRNA.silent = 1;
1013                                 RNA_def_property_float_sdna(prop, NULL, identifier);
1014                                 DefRNA.silent = 0;
1015                                 break;
1016                         }
1017                         case PROP_STRING: {
1018                                 DefRNA.silent = 1;
1019                                 RNA_def_property_string_sdna(prop, NULL, identifier);
1020                                 DefRNA.silent = 0;
1021                                 break;
1022                         }
1023                         case PROP_ENUM:
1024                                 DefRNA.silent = 1;
1025                                 RNA_def_property_enum_sdna(prop, NULL, identifier);
1026                                 DefRNA.silent = 0;
1027                                 break;
1028                         case PROP_POINTER:
1029                                 DefRNA.silent = 1;
1030                                 RNA_def_property_pointer_sdna(prop, NULL, identifier);
1031                                 DefRNA.silent = 0;
1032                                 break;
1033                         case PROP_COLLECTION:
1034                                 DefRNA.silent = 1;
1035                                 RNA_def_property_collection_sdna(prop, NULL, identifier, NULL);
1036                                 DefRNA.silent = 0;
1037                                 break;
1038                 }
1039         }
1040         else {
1041                 prop->flag |= PROP_IDPROPERTY|PROP_RUNTIME;
1042 #ifdef RNA_RUNTIME
1043                 if (cont->prophash)
1044                         BLI_ghash_insert(cont->prophash, (void*)prop->identifier, prop);
1045 #endif
1046         }
1047
1048         rna_addtail(&cont->properties, prop);
1049
1050         return prop;
1051 }
1052
1053 void RNA_def_property_flag(PropertyRNA *prop, int flag)
1054 {
1055         prop->flag |= flag;
1056 }
1057
1058 void RNA_def_property_clear_flag(PropertyRNA *prop, int flag)
1059 {
1060         prop->flag &= ~flag;
1061 }
1062
1063 void RNA_def_property_subtype(PropertyRNA *prop, PropertySubType subtype)
1064 {
1065         prop->subtype = subtype;
1066 }
1067
1068 void RNA_def_property_array(PropertyRNA *prop, int length)
1069 {
1070         StructRNA *srna = DefRNA.laststruct;
1071
1072         if (length<0) {
1073                 fprintf(stderr, "%s: \"%s.%s\", array length must be zero of greater.\n", __func__,
1074                         srna->identifier, prop->identifier);
1075                 DefRNA.error = 1;
1076                 return;
1077         }
1078
1079         if (length>RNA_MAX_ARRAY_LENGTH) {
1080                 fprintf(stderr, "%s: \"%s.%s\", array length must be smaller than %d.\n", __func__,
1081                         srna->identifier, prop->identifier, RNA_MAX_ARRAY_LENGTH);
1082                 DefRNA.error = 1;
1083                 return;
1084         }
1085
1086         if (prop->arraydimension > 1) {
1087                 fprintf(stderr, "%s: \"%s.%s\", array dimensions has been set to %u but would be overwritten as 1.\n",
1088                         __func__, srna->identifier, prop->identifier, prop->arraydimension);
1089                 DefRNA.error = 1;
1090                 return;
1091         }
1092
1093         switch (prop->type) {
1094                 case PROP_BOOLEAN:
1095                 case PROP_INT:
1096                 case PROP_FLOAT:
1097                         prop->arraylength[0] = length;
1098                         prop->totarraylength = length;
1099                         prop->arraydimension = 1;
1100                         break;
1101                 default:
1102                         fprintf(stderr, "%s: \"%s.%s\", only boolean/int/float can be array.\n",
1103                                 __func__, srna->identifier, prop->identifier);
1104                         DefRNA.error = 1;
1105                         break;
1106         }
1107 }
1108
1109 void RNA_def_property_multi_array(PropertyRNA *prop, int dimension, const int length[])
1110 {
1111         StructRNA *srna = DefRNA.laststruct;
1112         int i;
1113         
1114         if (dimension < 1 || dimension > RNA_MAX_ARRAY_DIMENSION) {
1115                 fprintf(stderr, "%s: \"%s.%s\", array dimension must be between 1 and %d.\n",
1116                         __func__, srna->identifier, prop->identifier, RNA_MAX_ARRAY_DIMENSION);
1117                 DefRNA.error = 1;
1118                 return;
1119         }
1120
1121         switch (prop->type) {
1122                 case PROP_BOOLEAN:
1123                 case PROP_INT:
1124                 case PROP_FLOAT:
1125                         break;
1126                 default:
1127                         fprintf(stderr, "%s: \"%s.%s\", only boolean/int/float can be array.\n",
1128                                 __func__, srna->identifier, prop->identifier);
1129                         DefRNA.error = 1;
1130                         break;
1131         }
1132
1133         prop->arraydimension = dimension;
1134         prop->totarraylength = 0;
1135
1136         if (length) {
1137                 memcpy(prop->arraylength, length, sizeof(int)*dimension);
1138
1139                 prop->totarraylength = length[0];
1140                 for (i = 1; i<dimension; i++)
1141                         prop->totarraylength *= length[i];
1142         }
1143         else
1144                 memset(prop->arraylength, 0, sizeof(prop->arraylength));
1145
1146         /* TODO make sure arraylength values are sane  */
1147 }
1148
1149 void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description)
1150 {
1151         DESCR_CHECK(description, prop->identifier, NULL);
1152
1153         prop->name = name;
1154         prop->description = description;
1155 }
1156
1157 void RNA_def_property_ui_icon(PropertyRNA *prop, int icon, int consecutive)
1158 {
1159         prop->icon = icon;
1160         if (consecutive)
1161                 prop->flag |= PROP_ICONS_CONSECUTIVE;
1162 }
1163
1164 void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
1165 {
1166         StructRNA *srna = DefRNA.laststruct;
1167
1168         switch (prop->type) {
1169                 case PROP_INT: {
1170                         IntPropertyRNA *iprop = (IntPropertyRNA*)prop;
1171                         iprop->softmin = (int)min;
1172                         iprop->softmax = (int)max;
1173                         iprop->step = (int)step;
1174                         break;
1175                 }
1176                 case PROP_FLOAT: {
1177                         FloatPropertyRNA *fprop = (FloatPropertyRNA*)prop;
1178                         fprop->softmin = (float)min;
1179                         fprop->softmax = (float)max;
1180                         fprop->step = (float)step;
1181                         fprop->precision = (int)precision;
1182                         break;
1183                 }
1184                 default:
1185                         fprintf(stderr, "%s: \"%s.%s\", invalid type for ui range.\n",
1186                                 __func__, srna->identifier, prop->identifier);
1187                         DefRNA.error = 1;
1188                         break;
1189         }
1190 }
1191
1192 void RNA_def_property_range(PropertyRNA *prop, double min, double max)
1193 {
1194         StructRNA *srna = DefRNA.laststruct;
1195
1196         switch (prop->type) {
1197                 case PROP_INT: {
1198                         IntPropertyRNA *iprop = (IntPropertyRNA*)prop;
1199                         iprop->hardmin = (int)min;
1200                         iprop->hardmax = (int)max;
1201                         iprop->softmin = MAX2((int)min, iprop->hardmin);
1202                         iprop->softmax = MIN2((int)max, iprop->hardmax);
1203                         break;
1204                 }
1205                 case PROP_FLOAT: {
1206                         FloatPropertyRNA *fprop = (FloatPropertyRNA*)prop;
1207                         fprop->hardmin = (float)min;
1208                         fprop->hardmax = (float)max;
1209                         fprop->softmin = MAX2((float)min, fprop->hardmin);
1210                         fprop->softmax = MIN2((float)max, fprop->hardmax);
1211                         break;
1212                 }
1213                 default:
1214                         fprintf(stderr, "%s: \"%s.%s\", invalid type for range.\n", __func__, srna->identifier, prop->identifier);
1215                         DefRNA.error = 1;
1216                         break;
1217         }
1218 }
1219
1220 void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
1221 {
1222         StructRNA *srna = DefRNA.laststruct;
1223
1224         if (!DefRNA.preprocess) {
1225                 fprintf(stderr, "%s \"%s.%s\": only during preprocessing.\n", __func__, srna->identifier, prop->identifier);
1226                 return;
1227         }
1228
1229         switch (prop->type) {
1230                 case PROP_POINTER: {
1231                         PointerPropertyRNA *pprop = (PointerPropertyRNA*)prop;
1232                         pprop->type = (StructRNA*)type;
1233                         break;
1234                 }
1235                 case PROP_COLLECTION: {
1236                         CollectionPropertyRNA *cprop = (CollectionPropertyRNA*)prop;
1237                         cprop->item_type = (StructRNA*)type;
1238                         break;
1239                 }
1240                 default:
1241                         fprintf(stderr, "%s: \"%s.%s\", invalid type for struct type.\n",
1242                                 __func__, srna->identifier, prop->identifier);
1243                         DefRNA.error = 1;
1244                         break;
1245         }
1246 }
1247
1248 void RNA_def_property_struct_runtime(PropertyRNA *prop, StructRNA *type)
1249 {
1250         StructRNA *srna = DefRNA.laststruct;
1251
1252         if (DefRNA.preprocess) {
1253                 fprintf(stderr, "%s: only at runtime.\n", __func__);
1254                 return;
1255         }
1256
1257         switch (prop->type) {
1258                 case PROP_POINTER: {
1259                         PointerPropertyRNA *pprop = (PointerPropertyRNA*)prop;
1260                         pprop->type = type;
1261
1262                         if (type && (type->flag & STRUCT_ID_REFCOUNT))
1263                                 prop->flag |= PROP_ID_REFCOUNT;
1264
1265                         break;
1266                 }
1267                 case PROP_COLLECTION: {
1268                         CollectionPropertyRNA *cprop = (CollectionPropertyRNA*)prop;
1269                         cprop->item_type = type;
1270                         break;
1271                 }
1272                 default:
1273                         fprintf(stderr, "%s: \"%s.%s\", invalid type for struct type.\n",
1274                                 __func__, srna->identifier, prop->identifier);
1275                         DefRNA.error = 1;
1276                         break;
1277         }
1278 }
1279
1280 void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item)
1281 {
1282         StructRNA *srna = DefRNA.laststruct;
1283         int i, defaultfound = 0;
1284
1285         switch (prop->type) {
1286                 case PROP_ENUM: {
1287                         EnumPropertyRNA *eprop = (EnumPropertyRNA*)prop;
1288                         eprop->item = (EnumPropertyItem*)item;
1289                         eprop->totitem = 0;
1290                         for (i = 0; item[i].identifier; i++) {
1291                                 eprop->totitem++;
1292
1293                                 if (item[i].identifier[0] && item[i].value == eprop->defaultvalue)
1294                                         defaultfound = 1;
1295                         }
1296
1297                         if (!defaultfound) {
1298                                 for (i = 0; item[i].identifier; i++) {
1299                                         if (item[i].identifier[0]) {
1300                                                 eprop->defaultvalue = item[i].value;
1301                                                 break;
1302                                         }
1303                                 }
1304                         }
1305
1306                         break;
1307                 }
1308                 default:
1309                         fprintf(stderr, "%s: \"%s.%s\", invalid type for struct type.\n",
1310                                 __func__, srna->identifier, prop->identifier);
1311                         DefRNA.error = 1;
1312                         break;
1313         }
1314 }
1315
1316 void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
1317 {
1318         StructRNA *srna = DefRNA.laststruct;
1319
1320         switch (prop->type) {
1321                 case PROP_STRING: {
1322                         StringPropertyRNA *sprop = (StringPropertyRNA*)prop;
1323                         sprop->maxlength = maxlength;
1324                         break;
1325                 }
1326                 default:
1327                         fprintf(stderr, "%s: \"%s.%s\", type is not string.\n", __func__, srna->identifier, prop->identifier);
1328                         DefRNA.error = 1;
1329                         break;
1330         }
1331 }
1332
1333 void RNA_def_property_boolean_default(PropertyRNA *prop, int value)
1334 {
1335         StructRNA *srna = DefRNA.laststruct;
1336
1337         switch (prop->type) {
1338                 case PROP_BOOLEAN: {
1339                         BoolPropertyRNA *bprop = (BoolPropertyRNA*)prop;
1340                         bprop->defaultvalue = value;
1341                         break;
1342                 }
1343                 default:
1344                         fprintf(stderr, "%s: \"%s.%s\", type is not boolean.\n", __func__, srna->identifier, prop->identifier);
1345                         DefRNA.error = 1;
1346                         break;
1347         }
1348 }
1349
1350 void RNA_def_property_boolean_array_default(PropertyRNA *prop, const int *array)
1351 {
1352         StructRNA *srna = DefRNA.laststruct;
1353
1354         switch (prop->type) {
1355                 case PROP_BOOLEAN: {
1356                         BoolPropertyRNA *bprop = (BoolPropertyRNA*)prop;
1357                         bprop->defaultarray = array;
1358                         break;
1359                 }
1360                 default:
1361                         fprintf(stderr, "%s: \"%s.%s\", type is not boolean.\n", __func__, srna->identifier, prop->identifier);
1362                         DefRNA.error = 1;
1363                         break;
1364         }
1365 }
1366
1367 void RNA_def_property_int_default(PropertyRNA *prop, int value)
1368 {
1369         StructRNA *srna = DefRNA.laststruct;
1370
1371         switch (prop->type) {
1372                 case PROP_INT: {
1373                         IntPropertyRNA *iprop = (IntPropertyRNA*)prop;
1374                         iprop->defaultvalue = value;
1375                         break;
1376                 }
1377                 default:
1378                         fprintf(stderr, "%s: \"%s.%s\", type is not int.\n", __func__, srna->identifier, prop->identifier);
1379                         DefRNA.error = 1;
1380                         break;
1381         }
1382 }
1383
1384 void RNA_def_property_int_array_default(PropertyRNA *prop, const int *array)
1385 {
1386         StructRNA *srna = DefRNA.laststruct;
1387
1388         switch (prop->type) {
1389                 case PROP_INT: {
1390                         IntPropertyRNA *iprop = (IntPropertyRNA*)prop;
1391                         iprop->defaultarray = array;
1392                         break;
1393                 }
1394                 default:
1395                         fprintf(stderr, "%s: \"%s.%s\", type is not int.\n", __func__, srna->identifier, prop->identifier);
1396                         DefRNA.error = 1;
1397                         break;
1398         }
1399 }
1400
1401 void RNA_def_property_float_default(PropertyRNA *prop, float value)
1402 {
1403         StructRNA *srna = DefRNA.laststruct;
1404
1405         switch (prop->type) {
1406                 case PROP_FLOAT: {
1407                         FloatPropertyRNA *fprop = (FloatPropertyRNA*)prop;
1408                         fprop->defaultvalue = value;
1409                         break;
1410                 }
1411                 default:
1412                         fprintf(stderr, "%s: \"%s.%s\", type is not float.\n", __func__, srna->identifier, prop->identifier);
1413                         DefRNA.error = 1;
1414                         break;
1415         }
1416 }
1417 /* array must remain valid after this function finishes */
1418 void RNA_def_property_float_array_default(PropertyRNA *prop, const float *array)
1419 {
1420         StructRNA *srna = DefRNA.laststruct;
1421
1422         switch (prop->type) {
1423                 case PROP_FLOAT: {
1424                         FloatPropertyRNA *fprop = (FloatPropertyRNA*)prop;
1425                         fprop->defaultarray = array; /* WARNING, this array must not come from the stack and lost */
1426                         break;
1427                 }
1428                 default:
1429                         fprintf(stderr, "%s: \"%s.%s\", type is not float.\n", __func__, srna->identifier, prop->identifier);
1430                         DefRNA.error = 1;
1431                         break;
1432         }
1433 }
1434
1435 void RNA_def_property_string_default(PropertyRNA *prop, const char *value)
1436 {
1437         StructRNA *srna = DefRNA.laststruct;
1438
1439         switch (prop->type) {
1440                 case PROP_STRING: {
1441                         StringPropertyRNA *sprop = (StringPropertyRNA*)prop;
1442                         sprop->defaultvalue = value;
1443                         break;
1444                 }
1445                 default:
1446                         fprintf(stderr, "%s: \"%s.%s\", type is not string.\n", __func__, srna->identifier, prop->identifier);
1447                         DefRNA.error = 1;
1448                         break;
1449         }
1450 }
1451
1452 void RNA_def_property_enum_default(PropertyRNA *prop, int value)
1453 {
1454         StructRNA *srna = DefRNA.laststruct;
1455         int i, defaultfound = 0;
1456
1457         switch (prop->type) {
1458                 case PROP_ENUM: {
1459                         EnumPropertyRNA *eprop = (EnumPropertyRNA*)prop;
1460                         eprop->defaultvalue = value;
1461
1462                         if (prop->flag & PROP_ENUM_FLAG) {
1463                                 /* check all bits are accounted for */
1464                                 int totflag = 0;
1465                                 for (i = 0; i<eprop->totitem; i++) {
1466                                         if (eprop->item[i].identifier[0]) {
1467                                                 totflag |= eprop->item[i].value;
1468                                         }
1469                                 }
1470
1471                                 if (eprop->defaultvalue & ~totflag) {
1472                                         fprintf(stderr, "%s: \"%s.%s\", default includes unused bits (%d).\n",
1473                                                 __func__, srna->identifier, prop->identifier, eprop->defaultvalue & ~totflag);
1474                                         DefRNA.error = 1;
1475                                 }
1476                         }
1477                         else {
1478                                 for (i = 0; i<eprop->totitem; i++) {
1479                                         if (eprop->item[i].identifier[0] && eprop->item[i].value == eprop->defaultvalue)
1480                                                 defaultfound = 1;
1481                                 }
1482
1483                                 if (!defaultfound && eprop->totitem) {
1484                                         if (value == 0) {
1485                                                 eprop->defaultvalue = eprop->item[0].value;
1486                                         }
1487                                         else {
1488                                                 fprintf(stderr, "%s: \"%s.%s\", default is not in items.\n",
1489                                                         __func__, srna->identifier, prop->identifier);
1490                                                 DefRNA.error = 1;
1491                                         }
1492                                 }
1493                         }
1494
1495                         break;
1496                 }
1497                 default:
1498                         fprintf(stderr, "%s: \"%s.%s\", type is not enum.\n", __func__, srna->identifier, prop->identifier);
1499                         DefRNA.error = 1;
1500                         break;
1501         }
1502 }
1503
1504 /* SDNA */
1505
1506 static PropertyDefRNA *rna_def_property_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1507 {
1508         DNAStructMember smember;
1509         StructDefRNA *ds;
1510         PropertyDefRNA *dp;
1511
1512         dp = rna_find_struct_property_def(DefRNA.laststruct, prop);
1513         if (dp == NULL) return NULL;
1514
1515         ds = rna_find_struct_def((StructRNA*)dp->cont);
1516
1517         if (!structname)
1518                 structname = ds->dnaname;
1519         if (!propname)
1520                 propname = prop->identifier;
1521
1522         if (!rna_find_sdna_member(DefRNA.sdna, structname, propname, &smember)) {
1523                 if (DefRNA.silent) {
1524                         return NULL;
1525                 }
1526                 else if (!DefRNA.verify) {
1527                         /* some basic values to survive even with sdna info */
1528                         dp->dnastructname = structname;
1529                         dp->dnaname = propname;
1530                         if (prop->type == PROP_BOOLEAN)
1531                                 dp->dnaarraylength = 1;
1532                         if (prop->type == PROP_POINTER)
1533                                 dp->dnapointerlevel = 1;
1534                         return dp;
1535                 }
1536                 else {
1537                         fprintf(stderr, "%s: \"%s.%s\" (identifier \"%s\") not found.\n",
1538                                 __func__, structname, propname, prop->identifier);
1539                         DefRNA.error = 1;
1540                         return NULL;
1541                 }
1542         }
1543
1544         if (smember.arraylength > 1) {
1545                 prop->arraylength[0] = smember.arraylength;
1546                 prop->totarraylength = smember.arraylength;
1547                 prop->arraydimension = 1;
1548         }
1549         else {
1550                 prop->arraydimension = 0;
1551                 prop->totarraylength = 0;
1552         }
1553         
1554         dp->dnastructname = structname;
1555         dp->dnastructfromname = ds->dnafromname;
1556         dp->dnastructfromprop = ds->dnafromprop;
1557         dp->dnaname = propname;
1558         dp->dnatype = smember.type;
1559         dp->dnaarraylength = smember.arraylength;
1560         dp->dnapointerlevel = smember.pointerlevel;
1561
1562         return dp;
1563 }
1564
1565 void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int bit)
1566 {
1567         PropertyDefRNA *dp;
1568         StructRNA *srna = DefRNA.laststruct;
1569         
1570         if (!DefRNA.preprocess) {
1571                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1572                 return;
1573         }
1574
1575         if (prop->type != PROP_BOOLEAN) {
1576                 fprintf(stderr, "%s: \"%s.%s\", type is not boolean.\n", __func__, srna->identifier, prop->identifier);
1577                 DefRNA.error = 1;
1578                 return;
1579         }
1580
1581         if ((dp = rna_def_property_sdna(prop, structname, propname))) {
1582
1583                 if (DefRNA.silent == 0) {
1584                         /* error check to ensure floats are not wrapped as ints/bools */
1585                         if (dp->dnatype && *dp->dnatype && IS_DNATYPE_INT_COMPAT(dp->dnatype) == 0) {
1586                                 fprintf(stderr, "%s: %s.%s is a '%s' but wrapped as type '%s'.\n",
1587                                         __func__, srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
1588                                 DefRNA.error = 1;
1589                                 return;
1590                         }
1591                 }
1592
1593                 dp->booleanbit = bit;
1594         }
1595 }
1596
1597 void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname,
1598                                             const char *propname, int booleanbit)
1599 {
1600         PropertyDefRNA *dp;
1601
1602         RNA_def_property_boolean_sdna(prop, structname, propname, booleanbit);
1603
1604         dp = rna_find_struct_property_def(DefRNA.laststruct, prop);
1605
1606         if (dp)
1607                 dp->booleannegative = 1;
1608 }
1609
1610 void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1611 {
1612         PropertyDefRNA *dp;
1613         IntPropertyRNA *iprop = (IntPropertyRNA*)prop;
1614         StructRNA *srna = DefRNA.laststruct;
1615         
1616         if (!DefRNA.preprocess) {
1617                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1618                 return;
1619         }
1620
1621         if (prop->type != PROP_INT) {
1622                 fprintf(stderr, "%s: \"%s.%s\", type is not int.\n", __func__, srna->identifier, prop->identifier);
1623                 DefRNA.error = 1;
1624                 return;
1625         }
1626
1627         if ((dp = rna_def_property_sdna(prop, structname, propname))) {
1628
1629                 /* error check to ensure floats are not wrapped as ints/bools */
1630                 if (DefRNA.silent == 0) {
1631                         if (dp->dnatype && *dp->dnatype && IS_DNATYPE_INT_COMPAT(dp->dnatype) == 0) {
1632                                 fprintf(stderr, "%s: %s.%s is a '%s' but wrapped as type '%s'.\n",
1633                                         __func__, srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
1634                                 DefRNA.error = 1;
1635                                 return;
1636                         }
1637                 }
1638
1639                 /* SDNA doesn't pass us unsigned unfortunately .. */
1640                 if (dp->dnatype && strcmp(dp->dnatype, "char") == 0) {
1641                         iprop->hardmin = iprop->softmin = CHAR_MIN;
1642                         iprop->hardmax = iprop->softmax = CHAR_MAX;
1643                 }
1644                 else if (dp->dnatype && strcmp(dp->dnatype, "short") == 0) {
1645                         iprop->hardmin = iprop->softmin = SHRT_MIN;
1646                         iprop->hardmax = iprop->softmax = SHRT_MAX;
1647                 }
1648                 else if (dp->dnatype && strcmp(dp->dnatype, "int") == 0) {
1649                         iprop->hardmin = INT_MIN;
1650                         iprop->hardmax = INT_MAX;
1651
1652                         iprop->softmin = -10000; /* rather arbitrary .. */
1653                         iprop->softmax = 10000;
1654                 }
1655
1656                 if (prop->subtype == PROP_UNSIGNED || prop->subtype == PROP_PERCENTAGE || prop->subtype == PROP_FACTOR)
1657                         iprop->hardmin = iprop->softmin = 0;
1658         }
1659 }
1660
1661 void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1662 {
1663         PropertyDefRNA *dp;
1664         FloatPropertyRNA *fprop = (FloatPropertyRNA*)prop;
1665         StructRNA *srna = DefRNA.laststruct;
1666
1667         if (!DefRNA.preprocess) {
1668                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1669                 return;
1670         }
1671
1672         if (prop->type != PROP_FLOAT) {
1673                 fprintf(stderr, "%s: \"%s.%s\", type is not float.\n", __func__, srna->identifier, prop->identifier);
1674                 DefRNA.error = 1;
1675                 return;
1676         }
1677
1678         if ((dp = rna_def_property_sdna(prop, structname, propname))) {
1679                 /* silent is for internal use */
1680                 if (DefRNA.silent == 0) {
1681                         if (dp->dnatype && *dp->dnatype && IS_DNATYPE_FLOAT_COMPAT(dp->dnatype) == 0) {
1682                                 if (prop->subtype != PROP_COLOR_GAMMA) { /* colors are an exception. these get translated */
1683                                         fprintf(stderr, "%s: %s.%s is a '%s' but wrapped as type '%s'.\n",
1684                                                 __func__, srna->identifier, prop->identifier, dp->dnatype,
1685                                                 RNA_property_typename(prop->type));
1686                                         DefRNA.error = 1;
1687                                         return;
1688                                 }
1689                         }
1690                 }
1691
1692                 if (dp->dnatype && strcmp(dp->dnatype, "char") == 0) {
1693                         fprop->hardmin = fprop->softmin = 0.0f;
1694                         fprop->hardmax = fprop->softmax = 1.0f;
1695                 }
1696         }
1697
1698         rna_def_property_sdna(prop, structname, propname);
1699 }
1700
1701 void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1702 {
1703         /* PropertyDefRNA *dp; */
1704         StructRNA *srna = DefRNA.laststruct;
1705         
1706         if (!DefRNA.preprocess) {
1707                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1708                 return;
1709         }
1710
1711         if (prop->type != PROP_ENUM) {
1712                 fprintf(stderr, "%s: \"%s.%s\", type is not enum.\n", __func__, srna->identifier, prop->identifier);
1713                 DefRNA.error = 1;
1714                 return;
1715         }
1716
1717         if (( /* dp= */ rna_def_property_sdna(prop, structname, propname))) {
1718                 if (prop->arraydimension) {
1719                         prop->arraydimension = 0;
1720                         prop->totarraylength = 0;
1721
1722                         if (!DefRNA.silent) {
1723                                 fprintf(stderr, "%s: \"%s.%s\", array not supported for enum type.\n",
1724                                         __func__, structname, propname);
1725                                 DefRNA.error = 1;
1726                         }
1727                 }
1728         }
1729 }
1730
1731 void RNA_def_property_enum_bitflag_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1732 {
1733         PropertyDefRNA *dp;
1734
1735         RNA_def_property_enum_sdna(prop, structname, propname);
1736
1737         dp = rna_find_struct_property_def(DefRNA.laststruct, prop);
1738
1739         if (dp)
1740                 dp->enumbitflags = 1;
1741 }
1742
1743 void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1744 {
1745         /* PropertyDefRNA *dp; */
1746         StringPropertyRNA *sprop = (StringPropertyRNA*)prop;
1747         StructRNA *srna = DefRNA.laststruct;
1748
1749         if (!DefRNA.preprocess) {
1750                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1751                 return;
1752         }
1753
1754         if (prop->type != PROP_STRING) {
1755                 fprintf(stderr, "%s: \"%s.%s\", type is not string.\n", __func__, srna->identifier, prop->identifier);
1756                 DefRNA.error = 1;
1757                 return;
1758         }
1759
1760         if ((/* dp= */ rna_def_property_sdna(prop, structname, propname))) {
1761                 if (prop->arraydimension) {
1762                         sprop->maxlength = prop->totarraylength;
1763                         prop->arraydimension = 0;
1764                         prop->totarraylength = 0;
1765                 }
1766         }
1767 }
1768
1769 void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1770 {
1771         /* PropertyDefRNA *dp; */
1772         StructRNA *srna = DefRNA.laststruct;
1773         
1774         if (!DefRNA.preprocess) {
1775                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1776                 return;
1777         }
1778
1779         if (prop->type != PROP_POINTER) {
1780                 fprintf(stderr, "%s: \"%s.%s\", type is not pointer.\n", __func__, srna->identifier, prop->identifier);
1781                 DefRNA.error = 1;
1782                 return;
1783         }
1784
1785         if ((/* dp= */ rna_def_property_sdna(prop, structname, propname))) {
1786                 if (prop->arraydimension) {
1787                         prop->arraydimension = 0;
1788                         prop->totarraylength = 0;
1789
1790                         if (!DefRNA.silent) {
1791                                 fprintf(stderr, "%s: \"%s.%s\", array not supported for pointer type.\n",
1792                                         __func__, structname, propname);
1793                                 DefRNA.error = 1;
1794                         }
1795                 }
1796         }
1797 }
1798
1799 void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname,
1800                                       const char *lengthpropname)
1801 {
1802         PropertyDefRNA *dp;
1803         CollectionPropertyRNA *cprop = (CollectionPropertyRNA*)prop;
1804         StructRNA *srna = DefRNA.laststruct;
1805
1806         if (!DefRNA.preprocess) {
1807                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1808                 return;
1809         }
1810
1811         if (prop->type != PROP_COLLECTION) {
1812                 fprintf(stderr, "%s: \"%s.%s\", type is not collection.\n", __func__, srna->identifier, prop->identifier);
1813                 DefRNA.error = 1;
1814                 return;
1815         }
1816
1817         if ((dp = rna_def_property_sdna(prop, structname, propname))) {
1818                 if (prop->arraydimension && !lengthpropname) {
1819                         prop->arraydimension = 0;
1820                         prop->totarraylength = 0;
1821
1822                         if (!DefRNA.silent) {
1823                                 fprintf(stderr, "%s: \"%s.%s\", array of collections not supported.\n",
1824                                         __func__, structname, propname);
1825                                 DefRNA.error = 1;
1826                         }
1827                 }
1828
1829                 if (dp->dnatype && strcmp(dp->dnatype, "ListBase") == 0) {
1830                         cprop->next = (PropCollectionNextFunc)"rna_iterator_listbase_next";
1831                         cprop->get = (PropCollectionGetFunc)"rna_iterator_listbase_get";
1832                         cprop->end = (PropCollectionEndFunc)"rna_iterator_listbase_end";
1833                 }
1834         }
1835
1836         if (dp && lengthpropname) {
1837                 DNAStructMember smember;
1838                 StructDefRNA *ds = rna_find_struct_def((StructRNA*)dp->cont);
1839
1840                 if (!structname)
1841                         structname = ds->dnaname;
1842
1843                 if (lengthpropname[0] == 0 || rna_find_sdna_member(DefRNA.sdna, structname, lengthpropname, &smember)) {
1844                         if (lengthpropname[0] == 0) {
1845                                 dp->dnalengthfixed = prop->totarraylength;
1846                                 prop->arraydimension = 0;
1847                                 prop->totarraylength = 0;
1848                         }
1849                         else {
1850                                 dp->dnalengthstructname = structname;
1851                                 dp->dnalengthname = lengthpropname;
1852                                 prop->totarraylength = 0;
1853                         }
1854
1855                         cprop->next = (PropCollectionNextFunc)"rna_iterator_array_next";
1856                         cprop->end = (PropCollectionEndFunc)"rna_iterator_array_end";
1857
1858                         if (dp->dnapointerlevel >= 2)
1859                                 cprop->get = (PropCollectionGetFunc)"rna_iterator_array_dereference_get";
1860                         else
1861                                 cprop->get = (PropCollectionGetFunc)"rna_iterator_array_get";
1862                 }
1863                 else {
1864                         if (!DefRNA.silent) {
1865                                 fprintf(stderr, "%s: \"%s.%s\" not found.\n", __func__, structname, lengthpropname);
1866                                 DefRNA.error = 1;
1867                         }
1868                 }
1869         }
1870 }
1871
1872 void RNA_def_property_translation_context(PropertyRNA *prop, const char *context)
1873 {
1874         prop->translation_context = context;
1875 }
1876
1877 /* Functions */
1878
1879 void RNA_def_property_editable_func(PropertyRNA *prop, const char *editable)
1880 {
1881         if (!DefRNA.preprocess) {
1882                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1883                 return;
1884         }
1885
1886         if (editable) prop->editable = (EditableFunc)editable;
1887 }
1888
1889 void RNA_def_property_editable_array_func(PropertyRNA *prop, const char *editable)
1890 {
1891         if (!DefRNA.preprocess) {
1892                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1893                 return;
1894         }
1895
1896         if (editable) prop->itemeditable = (ItemEditableFunc)editable;
1897 }
1898
1899 void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *func)
1900 {
1901         if (!DefRNA.preprocess) {
1902                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1903                 return;
1904         }
1905
1906         prop->noteflag = noteflag;
1907         prop->update = (UpdateFunc)func;
1908 }
1909
1910 void RNA_def_property_update_runtime(PropertyRNA *prop, void *func)
1911 {
1912         prop->update = func;
1913 }
1914
1915 void RNA_def_property_dynamic_array_funcs(PropertyRNA *prop, const char *getlength)
1916 {
1917         if (!DefRNA.preprocess) {
1918                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1919                 return;
1920         }
1921
1922         if (!(prop->flag & PROP_DYNAMIC)) {
1923                 fprintf(stderr, "%s: property is a not dynamic array.\n", __func__);
1924                 DefRNA.error = 1;
1925                 return;
1926         }
1927
1928         if (getlength) prop->getlength = (PropArrayLengthGetFunc)getlength;
1929 }
1930
1931 void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
1932 {
1933         StructRNA *srna = DefRNA.laststruct;
1934
1935         if (!DefRNA.preprocess) {
1936                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1937                 return;
1938         }
1939
1940         switch (prop->type) {
1941                 case PROP_BOOLEAN: {
1942                         BoolPropertyRNA *bprop = (BoolPropertyRNA*)prop;
1943
1944                         if (prop->arraydimension) {
1945                                 if (get) bprop->getarray = (PropBooleanArrayGetFunc)get;
1946                                 if (set) bprop->setarray = (PropBooleanArraySetFunc)set;
1947                         }
1948                         else {
1949                                 if (get) bprop->get = (PropBooleanGetFunc)get;
1950                                 if (set) bprop->set = (PropBooleanSetFunc)set;
1951                         }
1952                         break;
1953                 }
1954                 default:
1955                         fprintf(stderr, "%s: \"%s.%s\", type is not boolean.\n", __func__, srna->identifier, prop->identifier);
1956                         DefRNA.error = 1;
1957                         break;
1958         }
1959 }
1960
1961 void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
1962 {
1963         StructRNA *srna = DefRNA.laststruct;
1964
1965         if (!DefRNA.preprocess) {
1966                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1967                 return;
1968         }
1969
1970         switch (prop->type) {
1971                 case PROP_INT: {
1972                         IntPropertyRNA *iprop = (IntPropertyRNA*)prop;
1973
1974                         if (prop->arraydimension) {
1975                                 if (get) iprop->getarray = (PropIntArrayGetFunc)get;
1976                                 if (set) iprop->setarray = (PropIntArraySetFunc)set;
1977                         }
1978                         else {
1979                                 if (get) iprop->get = (PropIntGetFunc)get;
1980                                 if (set) iprop->set = (PropIntSetFunc)set;
1981                         }
1982                         if (range) iprop->range = (PropIntRangeFunc)range;
1983                         break;
1984                 }
1985                 default:
1986                         fprintf(stderr, "%s: \"%s.%s\", type is not int.\n", __func__, srna->identifier, prop->identifier);
1987                         DefRNA.error = 1;
1988                         break;
1989         }
1990 }
1991
1992 void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
1993 {
1994         StructRNA *srna = DefRNA.laststruct;
1995
1996         if (!DefRNA.preprocess) {
1997                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1998                 return;
1999         }
2000
2001         switch (prop->type) {
2002                 case PROP_FLOAT: {
2003                         FloatPropertyRNA *fprop = (FloatPropertyRNA*)prop;
2004
2005                         if (prop->arraydimension) {
2006                                 if (get) fprop->getarray = (PropFloatArrayGetFunc)get;
2007                                 if (set) fprop->setarray = (PropFloatArraySetFunc)set;
2008                         }
2009                         else {
2010                                 if (get) fprop->get = (PropFloatGetFunc)get;
2011                                 if (set) fprop->set = (PropFloatSetFunc)set;
2012                         }
2013                         if (range) fprop->range = (PropFloatRangeFunc)range;
2014                         break;
2015                 }
2016                 default:
2017                         fprintf(stderr, "%s: \"%s.%s\", type is not float.\n", __func__, srna->identifier, prop->identifier);
2018                         DefRNA.error = 1;
2019                         break;
2020         }
2021 }
2022
2023 void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char *set, const char *item)
2024 {
2025         StructRNA *srna = DefRNA.laststruct;
2026
2027         if (!DefRNA.preprocess) {
2028                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2029                 return;
2030         }
2031
2032         switch (prop->type) {
2033                 case PROP_ENUM: {
2034                         EnumPropertyRNA *eprop = (EnumPropertyRNA*)prop;
2035
2036                         if (get) eprop->get = (PropEnumGetFunc)get;
2037                         if (set) eprop->set = (PropEnumSetFunc)set;
2038                         if (item) eprop->itemf = (PropEnumItemFunc)item;
2039                         break;
2040                 }
2041                 default:
2042                         fprintf(stderr, "%s: \"%s.%s\", type is not enum.\n", __func__, srna->identifier, prop->identifier);
2043                         DefRNA.error = 1;
2044                         break;
2045         }
2046 }
2047
2048 void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
2049 {
2050         StructRNA *srna = DefRNA.laststruct;
2051
2052         if (!DefRNA.preprocess) {
2053                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2054                 return;
2055         }
2056
2057         switch (prop->type) {
2058                 case PROP_STRING: {
2059                         StringPropertyRNA *sprop = (StringPropertyRNA*)prop;
2060
2061                         if (get) sprop->get = (PropStringGetFunc)get;
2062                         if (length) sprop->length = (PropStringLengthFunc)length;
2063                         if (set) sprop->set = (PropStringSetFunc)set;
2064                         break;
2065                 }
2066                 default:
2067                         fprintf(stderr, "%s: \"%s.%s\", type is not string.\n", __func__, srna->identifier, prop->identifier);
2068                         DefRNA.error = 1;
2069                         break;
2070         }
2071 }
2072
2073 void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set,
2074                                     const char *typef, const char *poll)
2075 {
2076         StructRNA *srna = DefRNA.laststruct;
2077
2078         if (!DefRNA.preprocess) {
2079                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2080                 return;
2081         }
2082
2083         switch (prop->type) {
2084                 case PROP_POINTER: {
2085                         PointerPropertyRNA *pprop = (PointerPropertyRNA*)prop;
2086
2087                         if (get) pprop->get = (PropPointerGetFunc)get;
2088                         if (set) pprop->set = (PropPointerSetFunc)set;
2089                         if (typef) pprop->typef = (PropPointerTypeFunc)typef;
2090                         if (poll) pprop->poll = (PropPointerPollFunc)poll;
2091                         break;
2092                 }
2093                 default:
2094                         fprintf(stderr, "%s: \"%s.%s\", type is not pointer.\n", __func__, srna->identifier, prop->identifier);
2095                         DefRNA.error = 1;
2096                         break;
2097         }
2098 }
2099
2100 void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, const char *next, const char *end,
2101                                        const char *get, const char *length, const char *lookupint,
2102                                        const char *lookupstring, const char *assignint)
2103 {
2104         StructRNA *srna = DefRNA.laststruct;
2105
2106         if (!DefRNA.preprocess) {
2107                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2108                 return;
2109         }
2110
2111         switch (prop->type) {
2112                 case PROP_COLLECTION: {
2113                         CollectionPropertyRNA *cprop = (CollectionPropertyRNA*)prop;
2114
2115                         if (begin) cprop->begin = (PropCollectionBeginFunc)begin;
2116                         if (next) cprop->next = (PropCollectionNextFunc)next;
2117                         if (end) cprop->end = (PropCollectionEndFunc)end;
2118                         if (get) cprop->get = (PropCollectionGetFunc)get;
2119                         if (length) cprop->length = (PropCollectionLengthFunc)length;
2120                         if (lookupint) cprop->lookupint = (PropCollectionLookupIntFunc)lookupint;
2121                         if (lookupstring) cprop->lookupstring = (PropCollectionLookupStringFunc)lookupstring;
2122                         if (assignint) cprop->assignint = (PropCollectionAssignIntFunc)assignint;
2123                         break;
2124                 }
2125                 default:
2126                         fprintf(stderr, "%s: \"%s.%s\", type is not collection.\n", __func__, srna->identifier, prop->identifier);
2127                         DefRNA.error = 1;
2128                         break;
2129         }
2130 }
2131
2132 void RNA_def_property_srna(PropertyRNA *prop, const char *type)
2133 {
2134         prop->srna = (StructRNA*)type;
2135 }
2136
2137 void RNA_def_py_data(PropertyRNA *prop, void *py_data)
2138 {
2139         prop->py_data = py_data;
2140 }
2141
2142 /* Compact definitions */
2143
2144 PropertyRNA *RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, int default_value,
2145                              const char *ui_name, const char *ui_description)
2146 {
2147         ContainerRNA *cont = cont_;
2148         PropertyRNA *prop;
2149         
2150         prop = RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_NONE);
2151         RNA_def_property_boolean_default(prop, default_value);
2152         RNA_def_property_ui_text(prop, ui_name, ui_description);
2153
2154         return prop;
2155 }
2156
2157 PropertyRNA *RNA_def_boolean_array(StructOrFunctionRNA *cont_, const char *identifier, int len, int *default_value,
2158                                    const char *ui_name, const char *ui_description)
2159 {
2160         ContainerRNA *cont = cont_;
2161         PropertyRNA *prop;
2162         
2163         prop = RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_NONE);
2164         if (len != 0) RNA_def_property_array(prop, len);
2165         if (default_value) RNA_def_property_boolean_array_default(prop, default_value);
2166         RNA_def_property_ui_text(prop, ui_name, ui_description);
2167
2168         return prop;
2169 }
2170
2171 PropertyRNA *RNA_def_boolean_layer(StructOrFunctionRNA *cont_, const char *identifier, int len, int *default_value,
2172                                    const char *ui_name, const char *ui_description)
2173 {
2174         ContainerRNA *cont = cont_;
2175         PropertyRNA *prop;
2176         
2177         prop = RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_LAYER);
2178         if (len != 0) RNA_def_property_array(prop, len);
2179         if (default_value) RNA_def_property_boolean_array_default(prop, default_value);
2180         RNA_def_property_ui_text(prop, ui_name, ui_description);
2181
2182         return prop;
2183 }
2184
2185 PropertyRNA *RNA_def_boolean_layer_member(StructOrFunctionRNA *cont_, const char *identifier, int len,
2186                                           int *default_value, const char *ui_name, const char *ui_description)
2187 {
2188         ContainerRNA *cont = cont_;
2189         PropertyRNA *prop;
2190         
2191         prop = RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_LAYER_MEMBER);
2192         if (len != 0) RNA_def_property_array(prop, len);
2193         if (default_value) RNA_def_property_boolean_array_default(prop, default_value);
2194         RNA_def_property_ui_text(prop, ui_name, ui_description);
2195
2196         return prop;
2197 }
2198
2199 PropertyRNA *RNA_def_boolean_vector(StructOrFunctionRNA *cont_, const char *identifier, int len, int *default_value,
2200                                     const char *ui_name, const char *ui_description)
2201 {
2202         ContainerRNA *cont = cont_;
2203         PropertyRNA *prop;
2204         
2205         prop = RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_XYZ); /* XXX */
2206         if (len != 0) RNA_def_property_array(prop, len);
2207         if (default_value) RNA_def_property_boolean_array_default(prop, default_value);
2208         RNA_def_property_ui_text(prop, ui_name, ui_description);
2209
2210         return prop;
2211 }
2212
2213 PropertyRNA *RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, int default_value, int hardmin,
2214                          int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
2215 {
2216         ContainerRNA *cont = cont_;
2217         PropertyRNA *prop;
2218         
2219         prop = RNA_def_property(cont, identifier, PROP_INT, PROP_NONE);
2220         RNA_def_property_int_default(prop, default_value);
2221         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2222         RNA_def_property_ui_text(prop, ui_name, ui_description);
2223         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2224
2225         return prop;
2226 }
2227
2228 PropertyRNA *RNA_def_int_vector(StructOrFunctionRNA *cont_, const char *identifier, int len, const int *default_value,
2229                                 int hardmin, int hardmax, const char *ui_name, const char *ui_description,
2230                                 int softmin, int softmax)
2231 {
2232         ContainerRNA *cont = cont_;
2233         PropertyRNA *prop;
2234         
2235         prop = RNA_def_property(cont, identifier, PROP_INT, PROP_XYZ); /* XXX */
2236         if (len != 0) RNA_def_property_array(prop, len);
2237         if (default_value) RNA_def_property_int_array_default(prop, default_value);
2238         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2239         RNA_def_property_ui_text(prop, ui_name, ui_description);
2240         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2241
2242         return prop;
2243 }
2244
2245 PropertyRNA *RNA_def_int_array(StructOrFunctionRNA *cont_, const char *identifier, int len, const int *default_value,
2246                                int hardmin, int hardmax, const char *ui_name, const char *ui_description,
2247                                int softmin, int softmax)
2248 {
2249         ContainerRNA *cont = cont_;
2250         PropertyRNA *prop;
2251         
2252         prop = RNA_def_property(cont, identifier, PROP_INT, PROP_NONE);
2253         if (len != 0) RNA_def_property_array(prop, len);
2254         if (default_value) RNA_def_property_int_array_default(prop, default_value);
2255         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2256         RNA_def_property_ui_text(prop, ui_name, ui_description);
2257         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2258
2259         return prop;
2260 }
2261
2262 PropertyRNA *RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, int maxlen,
2263                             const char *ui_name, const char *ui_description)
2264 {
2265         ContainerRNA *cont = cont_;
2266         PropertyRNA *prop;
2267         
2268         prop = RNA_def_property(cont, identifier, PROP_STRING, PROP_NONE);
2269         if (maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
2270         if (default_value) RNA_def_property_string_default(prop, default_value);
2271         RNA_def_property_ui_text(prop, ui_name, ui_description);
2272
2273         return prop;
2274 }
2275
2276 PropertyRNA *RNA_def_string_file_path(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
2277                                       int maxlen, const char *ui_name, const char *ui_description)
2278 {
2279         ContainerRNA *cont = cont_;
2280         PropertyRNA *prop;
2281         
2282         prop = RNA_def_property(cont, identifier, PROP_STRING, PROP_FILEPATH);
2283         if (maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
2284         if (default_value) RNA_def_property_string_default(prop, default_value);
2285         RNA_def_property_ui_text(prop, ui_name, ui_description);
2286
2287         return prop;
2288 }
2289
2290 PropertyRNA *RNA_def_string_dir_path(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
2291                                      int maxlen, const char *ui_name, const char *ui_description)
2292 {
2293         ContainerRNA *cont = cont_;
2294         PropertyRNA *prop;
2295         
2296         prop = RNA_def_property(cont, identifier, PROP_STRING, PROP_DIRPATH);
2297         if (maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
2298         if (default_value) RNA_def_property_string_default(prop, default_value);
2299         RNA_def_property_ui_text(prop, ui_name, ui_description);
2300
2301         return prop;
2302 }
2303
2304 PropertyRNA *RNA_def_string_file_name(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
2305                                       int maxlen, const char *ui_name, const char *ui_description)
2306 {
2307         ContainerRNA *cont = cont_;
2308         PropertyRNA *prop;
2309         
2310         prop = RNA_def_property(cont, identifier, PROP_STRING, PROP_FILENAME);
2311         if (maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
2312         if (default_value) RNA_def_property_string_default(prop, default_value);
2313         RNA_def_property_ui_text(prop, ui_name, ui_description);
2314
2315         return prop;
2316 }
2317
2318 PropertyRNA *RNA_def_string_translate(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
2319                                       int maxlen, const char *ui_name, const char *ui_description)
2320 {
2321         ContainerRNA *cont = cont_;
2322         PropertyRNA *prop;
2323
2324         prop = RNA_def_property(cont, identifier, PROP_STRING, PROP_TRANSLATE);
2325         if (maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
2326         if (default_value) RNA_def_property_string_default(prop, default_value);
2327         RNA_def_property_ui_text(prop, ui_name, ui_description);
2328
2329         return prop;
2330 }
2331
2332 PropertyRNA *RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items,
2333                           int default_value, const char *ui_name, const char *ui_description)
2334 {
2335         ContainerRNA *cont = cont_;
2336         PropertyRNA *prop;
2337
2338         if (!items) {
2339                 printf("%s: items not allowed to be NULL.\n", __func__);
2340                 return NULL;
2341         }
2342         
2343         prop = RNA_def_property(cont, identifier, PROP_ENUM, PROP_NONE);
2344         if (items) RNA_def_property_enum_items(prop, items);
2345         RNA_def_property_enum_default(prop, default_value);
2346         RNA_def_property_ui_text(prop, ui_name, ui_description);
2347
2348         return prop;
2349 }
2350
2351 /* same as above but sets 'PROP_ENUM_FLAG' before setting the default value */
2352 PropertyRNA *RNA_def_enum_flag(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items,
2353                                int default_value, const char *ui_name, const char *ui_description)
2354 {
2355         ContainerRNA *cont = cont_;
2356         PropertyRNA *prop;
2357
2358         if (!items) {
2359                 printf("%s: items not allowed to be NULL.\n", __func__);
2360                 return NULL;
2361         }
2362
2363         prop = RNA_def_property(cont, identifier, PROP_ENUM, PROP_NONE);
2364         RNA_def_property_flag(prop, PROP_ENUM_FLAG); /* important to run before default set */
2365         if (items) RNA_def_property_enum_items(prop, items);
2366         RNA_def_property_enum_default(prop, default_value);
2367         RNA_def_property_ui_text(prop, ui_name, ui_description);
2368
2369         return prop;
2370 }
2371
2372 void RNA_def_enum_funcs(PropertyRNA *prop, EnumPropertyItemFunc itemfunc)
2373 {
2374         EnumPropertyRNA *eprop = (EnumPropertyRNA*)prop;
2375         eprop->itemf = itemfunc;
2376 }
2377
2378 void RNA_def_enum_py_data(PropertyRNA *prop, void *py_data)
2379 {
2380         EnumPropertyRNA *eprop = (EnumPropertyRNA*)prop;
2381         eprop->py_data = py_data;
2382 }
2383
2384 PropertyRNA *RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
2385                            float hardmin, float hardmax, const char *ui_name, const char *ui_description,
2386                            float softmin, float softmax)
2387 {
2388         ContainerRNA *cont = cont_;
2389         PropertyRNA *prop;
2390         
2391         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_NONE);
2392         RNA_def_property_float_default(prop, default_value);
2393         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2394         RNA_def_property_ui_text(prop, ui_name, ui_description);
2395         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2396
2397         return prop;
2398 }
2399
2400 PropertyRNA *RNA_def_float_vector(StructOrFunctionRNA *cont_, const char *identifier, int len,
2401                                   const float *default_value, float hardmin, float hardmax, const char *ui_name,
2402                                   const char *ui_description, float softmin, float softmax)
2403 {
2404         ContainerRNA *cont = cont_;
2405         PropertyRNA *prop;
2406         
2407         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_XYZ);
2408         if (len != 0) RNA_def_property_array(prop, len);
2409         if (default_value) RNA_def_property_float_array_default(prop, default_value);
2410         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2411         RNA_def_property_ui_text(prop, ui_name, ui_description);
2412         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2413
2414         return prop;
2415 }
2416
2417 PropertyRNA *RNA_def_float_vector_xyz(StructOrFunctionRNA *cont_, const char *identifier, int len,
2418                                       const float *default_value, float hardmin, float hardmax, const char *ui_name,
2419                                       const char *ui_description, float softmin, float softmax)
2420 {
2421         PropertyRNA *prop;
2422         
2423         prop = RNA_def_float_vector(cont_, identifier, len, default_value, hardmin, hardmax, ui_name, ui_description,
2424                                     softmin, softmax);
2425         prop->subtype = PROP_XYZ_LENGTH;
2426
2427         return prop;
2428 }
2429
2430 PropertyRNA *RNA_def_float_color(StructOrFunctionRNA *cont_, const char *identifier, int len,
2431                                  const float *default_value, float hardmin, float hardmax, const char *ui_name,
2432                                  const char *ui_description, float softmin, float softmax)
2433 {
2434         ContainerRNA *cont = cont_;
2435         PropertyRNA *prop;
2436         
2437         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_COLOR);
2438         if (len != 0) RNA_def_property_array(prop, len);
2439         if (default_value) RNA_def_property_float_array_default(prop, default_value);
2440         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2441         RNA_def_property_ui_text(prop, ui_name, ui_description);
2442         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2443
2444         return prop;
2445 }
2446
2447
2448 PropertyRNA *RNA_def_float_matrix(StructOrFunctionRNA *cont_, const char *identifier, int rows, int columns,
2449                                   const float *default_value, float hardmin, float hardmax, const char *ui_name,
2450                                   const char *ui_description, float softmin, float softmax)
2451 {
2452         ContainerRNA *cont = cont_;
2453         PropertyRNA *prop;
2454         int length[2];
2455
2456         length[0] = rows;
2457         length[1] = columns;
2458
2459         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_MATRIX);
2460         RNA_def_property_multi_array(prop, 2, length);
2461         if (default_value) RNA_def_property_float_array_default(prop, default_value);
2462         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2463         RNA_def_property_ui_text(prop, ui_name, ui_description);
2464         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2465
2466         return prop;
2467 }
2468
2469 PropertyRNA *RNA_def_float_rotation(StructOrFunctionRNA *cont_, const char *identifier, int len,
2470                                     const float *default_value, float hardmin, float hardmax, const char *ui_name,
2471                                     const char *ui_description, float softmin, float softmax)
2472 {
2473         ContainerRNA *cont = cont_;
2474         PropertyRNA *prop;
2475         
2476         prop = RNA_def_property(cont, identifier, PROP_FLOAT, (len != 0) ? PROP_EULER : PROP_ANGLE);
2477         if (len != 0) {
2478                 RNA_def_property_array(prop, len);
2479                 if (default_value) RNA_def_property_float_array_default(prop, default_value);
2480         }
2481         else {
2482                 /* RNA_def_property_float_default must be called outside */
2483                 BLI_assert(default_value == NULL);
2484         }
2485         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2486         RNA_def_property_ui_text(prop, ui_name, ui_description);
2487         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2488
2489         return prop;
2490 }
2491
2492 PropertyRNA *RNA_def_float_array(StructOrFunctionRNA *cont_, const char *identifier, int len,
2493                                  const float *default_value, float hardmin, float hardmax, const char *ui_name,
2494                                  const char *ui_description, float softmin, float softmax)
2495 {
2496         ContainerRNA *cont = cont_;
2497         PropertyRNA *prop;
2498         
2499         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_NONE);
2500         if (len != 0) RNA_def_property_array(prop, len);
2501         if (default_value) RNA_def_property_float_array_default(prop, default_value);
2502         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2503         RNA_def_property_ui_text(prop, ui_name, ui_description);
2504         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2505
2506         return prop;
2507 }
2508
2509 PropertyRNA *RNA_def_float_percentage(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
2510                                       float hardmin, float hardmax, const char *ui_name, const char *ui_description,
2511                                       float softmin, float softmax)
2512 {
2513         ContainerRNA *cont = cont_;
2514         PropertyRNA *prop;
2515         
2516         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_PERCENTAGE);
2517         RNA_def_property_float_default(prop, default_value);
2518         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2519         RNA_def_property_ui_text(prop, ui_name, ui_description);
2520         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2521
2522         return prop;
2523 }
2524
2525 PropertyRNA *RNA_def_float_factor(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
2526                                   float hardmin, float hardmax, const char *ui_name, const char *ui_description,
2527                                   float softmin, float softmax)
2528 {
2529         ContainerRNA *cont = cont_;
2530         PropertyRNA *prop;
2531         
2532         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_FACTOR);
2533         RNA_def_property_float_default(prop, default_value);
2534         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2535         RNA_def_property_ui_text(prop, ui_name, ui_description);
2536         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2537
2538         return prop;
2539 }
2540
2541 PropertyRNA *RNA_def_pointer(StructOrFunctionRNA *cont_, const char *identifier, const char *type,
2542                              const char *ui_name, const char *ui_description)
2543 {
2544         ContainerRNA *cont = cont_;
2545         PropertyRNA *prop;
2546         
2547         prop = RNA_def_property(cont, identifier, PROP_POINTER, PROP_NONE);
2548         RNA_def_property_struct_type(prop, type);
2549         RNA_def_property_ui_text(prop, ui_name, ui_description);
2550
2551         return prop;
2552 }
2553
2554 PropertyRNA *RNA_def_pointer_runtime(StructOrFunctionRNA *cont_, const char *identifier, StructRNA *type,
2555                                      const char *ui_name, const char *ui_description)
2556 {
2557         ContainerRNA *cont = cont_;
2558         PropertyRNA *prop;
2559         
2560         prop = RNA_def_property(cont, identifier, PROP_POINTER, PROP_NONE);
2561         RNA_def_property_struct_runtime(prop, type);
2562         RNA_def_property_ui_text(prop, ui_name, ui_description);
2563
2564         return prop;
2565 }
2566
2567 PropertyRNA *RNA_def_collection(StructOrFunctionRNA *cont_, const char *identifier, const char *type,
2568                                 const char *ui_name, const char *ui_description)
2569 {
2570         ContainerRNA *cont = cont_;
2571         PropertyRNA *prop;
2572         
2573         prop = RNA_def_property(cont, identifier, PROP_COLLECTION, PROP_NONE);
2574         RNA_def_property_struct_type(prop, type);
2575         RNA_def_property_ui_text(prop, ui_name, ui_description);
2576
2577         return prop;
2578 }
2579
2580 PropertyRNA *RNA_def_collection_runtime(StructOrFunctionRNA *cont_, const char *identifier, StructRNA *type,
2581                                         const char *ui_name, const char *ui_description)
2582 {
2583         ContainerRNA *cont = cont_;
2584         PropertyRNA *prop;
2585         
2586         prop = RNA_def_property(cont, identifier, PROP_COLLECTION, PROP_NONE);
2587         RNA_def_property_struct_runtime(prop, type);
2588         RNA_def_property_ui_text(prop, ui_name, ui_description);
2589
2590         return prop;
2591 }
2592
2593 /* Function */
2594
2595 static FunctionRNA *rna_def_function(StructRNA *srna, const char *identifier)
2596 {
2597         FunctionRNA *func;
2598         StructDefRNA *dsrna;
2599         FunctionDefRNA *dfunc;
2600
2601         if (DefRNA.preprocess) {
2602                 char error[512];
2603
2604                 if (rna_validate_identifier(identifier, error, 0) == 0) {
2605                         fprintf(stderr, "%s: function identifier \"%s\" - %s\n", __func__, identifier, error);
2606                         DefRNA.error = 1;
2607                 }
2608         }
2609
2610         func = MEM_callocN(sizeof(FunctionRNA), "FunctionRNA");
2611         func->identifier = identifier;
2612         func->description = identifier;
2613
2614         rna_addtail(&srna->functions, func);
2615
2616         if (DefRNA.preprocess) {
2617                 dsrna = rna_find_struct_def(srna);
2618                 dfunc = MEM_callocN(sizeof(FunctionDefRNA), "FunctionDefRNA");
2619                 rna_addtail(&dsrna->functions, dfunc);
2620                 dfunc->func = func;
2621         }
2622         else
2623                 func->flag |= FUNC_RUNTIME;
2624
2625         return func;
2626 }
2627
2628 FunctionRNA *RNA_def_function(StructRNA *srna, const char *identifier, const char *call)
2629 {
2630         FunctionRNA *func;
2631         FunctionDefRNA *dfunc;
2632
2633         func = rna_def_function(srna, identifier);
2634
2635         if (!DefRNA.preprocess) {
2636                 fprintf(stderr, "%s: only at preprocess time.\n", __func__);
2637                 return func;
2638         }
2639
2640         dfunc = rna_find_function_def(func);
2641         dfunc->call = call;
2642
2643         return func;
2644 }
2645
2646 FunctionRNA *RNA_def_function_runtime(StructRNA *srna, const char *identifier, CallFunc call)
2647 {
2648         FunctionRNA *func;
2649
2650         func = rna_def_function(srna, identifier);
2651
2652         if (DefRNA.preprocess) {
2653                 fprintf(stderr, "%s: only at runtime.\n", __func__);
2654                 return func;
2655         }
2656
2657         func->call = call;
2658
2659
2660         return func;
2661 }
2662
2663 /* C return value only!, multiple RNA returns can be done with RNA_def_function_output */
2664 void RNA_def_function_return(FunctionRNA *func, PropertyRNA *ret)
2665 {
2666         if (ret->flag & PROP_DYNAMIC) {
2667                 fprintf(stderr, "%s: \"%s.%s\", dynamic values are not allowed as strict returns, "
2668                         "use RNA_def_function_output instead.\n", __func__, func->identifier, ret->identifier);
2669                 return;
2670         }
2671         else if (ret->arraydimension) {
2672                 fprintf(stderr, "%s: \"%s.%s\", arrays are not allowed as strict returns, "
2673                         "use RNA_def_function_output instead.\n", __func__, func->identifier, ret->identifier);
2674                 return;
2675         }
2676
2677         func->c_ret = ret;
2678
2679         RNA_def_function_output(func, ret);
2680 }
2681
2682 void RNA_def_function_output(FunctionRNA *UNUSED(func), PropertyRNA *ret)
2683 {
2684         ret->flag |= PROP_OUTPUT;
2685 }
2686
2687 void RNA_def_function_flag(FunctionRNA *func, int flag)
2688 {
2689         func->flag |= flag;
2690 }
2691
2692 void RNA_def_function_ui_description(FunctionRNA *func, const char *description)
2693 {
2694         func->description = description;
2695 }
2696
2697 int rna_parameter_size(PropertyRNA *parm)
2698 {
2699         PropertyType ptype = parm->type;
2700         int len = parm->totarraylength; /* only supports fixed length at the moment */
2701
2702         if (len > 0) {
2703                 /* XXX in other parts is mentioned that strings can be dynamic as well */
2704                 if (parm->flag & PROP_DYNAMIC)
2705                         return sizeof(void *);
2706
2707                 switch (ptype) {
2708                         case PROP_BOOLEAN:
2709                         case PROP_INT:
2710                                 return sizeof(int)*len;
2711                         case PROP_FLOAT:
2712                                 return sizeof(float)*len;
2713                         default:
2714                                 break;
2715                 }
2716         }
2717         else {
2718                 switch (ptype) {
2719                         case PROP_BOOLEAN:
2720                         case PROP_INT:
2721                         case PROP_ENUM:
2722                                 return sizeof(int);
2723                         case PROP_FLOAT:
2724                                 return sizeof(float);
2725                         case PROP_STRING:
2726                                 /* return values don't store a pointer to the original */
2727                                 if (parm->flag & PROP_THICK_WRAP) {
2728                                         StringPropertyRNA *sparm = (StringPropertyRNA*)parm;
2729                                         return sizeof(char) * sparm->maxlength;
2730                                 }
2731                                 else
2732                                         return sizeof(char *);
2733                         case PROP_POINTER: {
2734 #ifdef RNA_RUNTIME
2735                                 if (parm->flag & PROP_RNAPTR)
2736                                         return sizeof(PointerRNA);
2737                                 else
2738                                         return sizeof(void *);
2739 #else
2740                                 if (parm->flag & PROP_RNAPTR)
2741                                         return sizeof(PointerRNA);
2742                                 else
2743                                         return sizeof(void *);
2744 #endif
2745                         }
2746                         case PROP_COLLECTION:
2747                                 return sizeof(ListBase);
2748                 }
2749         }
2750
2751         return sizeof(void *);
2752 }
2753
2754 /* this function returns the size of the memory allocated for the parameter,
2755  * useful for instance for memory alignment or for storing additional information */
2756 int rna_parameter_size_alloc(PropertyRNA *parm)
2757 {
2758         int size = rna_parameter_size(parm);
2759
2760         if (parm->flag & PROP_DYNAMIC)
2761                 size += sizeof(((ParameterDynAlloc *)NULL)->array_tot);
2762
2763         return size;
2764 }
2765
2766 /* Dynamic Enums */
2767
2768 void RNA_enum_item_add(EnumPropertyItem **items, int *totitem, const EnumPropertyItem *item)
2769 {
2770         EnumPropertyItem *newitems;
2771         int tot = *totitem;
2772
2773         if (tot == 0) {
2774                 *items = MEM_callocN(sizeof(EnumPropertyItem)*8, "RNA_enum_items_add");
2775         }
2776         else if (tot >= 8 && (tot&(tot-1)) == 0) {
2777                 /* power of two > 8 */
2778                 newitems = MEM_callocN(sizeof(EnumPropertyItem)*tot*2, "RNA_enum_items_add");
2779                 memcpy(newitems, *items, sizeof(EnumPropertyItem)*tot);
2780                 MEM_freeN(*items);
2781                 *items = newitems;
2782         }
2783
2784         (*items)[tot] = *item;
2785         *totitem = tot+1;
2786 }
2787
2788 void RNA_enum_item_add_separator(EnumPropertyItem **items, int *totitem)
2789 {
2790         static EnumPropertyItem sepr = {0, "", 0, NULL, NULL};
2791         RNA_enum_item_add(items, totitem, &sepr);
2792 }
2793
2794 void RNA_enum_items_add(EnumPropertyItem **items, int *totitem, EnumPropertyItem *item)
2795 {
2796         for (; item->identifier; item++)
2797                 RNA_enum_item_add(items, totitem, item);
2798 }
2799
2800 void RNA_enum_items_add_value(EnumPropertyItem **items, int *totitem, EnumPropertyItem *item, int value)
2801 {
2802         for (; item->identifier; item++) {
2803                 if (item->value == value) {
2804                         RNA_enum_item_add(items, totitem, item);
2805                         /* break on first match - does this break anything?
2806                          * (is quick hack to get object->parent_type working ok for armature/lattice) */
2807                         break;
2808                 }
2809         }
2810 }
2811
2812 void RNA_enum_item_end(EnumPropertyItem **items, int *totitem)
2813 {
2814         static EnumPropertyItem empty = {0, NULL, 0, NULL, NULL};
2815         RNA_enum_item_add(items, totitem, &empty);
2816 }
2817
2818 /* Memory management */
2819
2820 #ifdef RNA_RUNTIME
2821 void RNA_def_struct_duplicate_pointers(StructRNA *srna)
2822 {
2823         if (srna->identifier) srna->identifier = BLI_strdup(srna->identifier);
2824         if (srna->name) srna->name = BLI_strdup(srna->name);
2825         if (srna->description) srna->description = BLI_strdup(srna->description);
2826
2827         srna->flag |= STRUCT_FREE_POINTERS;
2828 }
2829
2830 void RNA_def_struct_free_pointers(StructRNA *srna)
2831 {
2832         if (srna->flag & STRUCT_FREE_POINTERS) {
2833                 if (srna->identifier) MEM_freeN((void*)srna->identifier);
2834                 if (srna->name) MEM_freeN((void*)srna->name);
2835                 if (srna->description) MEM_freeN((void*)srna->description);
2836         }
2837 }
2838
2839 void RNA_def_func_duplicate_pointers(FunctionRNA *func)
2840 {
2841         if (func->identifier) func->identifier = BLI_strdup(func->identifier);
2842         if (func->description) func->description = BLI_strdup(func->description);
2843
2844         func->flag |= FUNC_FREE_POINTERS;
2845 }
2846
2847 void RNA_def_func_free_pointers(FunctionRNA *func)
2848 {
2849         if (func->flag & FUNC_FREE_POINTERS) {
2850                 if (func->identifier) MEM_freeN((void*)func->identifier);
2851                 if (func->description) MEM_freeN((void*)func->description);
2852         }
2853 }
2854
2855 void RNA_def_property_duplicate_pointers(StructOrFunctionRNA *cont_, PropertyRNA *prop)
2856 {
2857         ContainerRNA *cont = cont_;
2858         EnumPropertyItem *earray;
2859         float *farray;
2860         int *iarray;
2861         int a;
2862
2863         /* annoying since we just added this to a hash, could make this add the correct key to the hash
2864          * in the first place */
2865         if (prop->identifier) {
2866                 if (cont->prophash) {
2867                         BLI_ghash_remove(cont->prophash, (void*)prop->identifier, NULL, NULL);
2868                         prop->identifier = BLI_strdup(prop->identifier);
2869                         BLI_ghash_insert(cont->prophash, (void*)prop->identifier, prop);
2870                 }
2871                 else {
2872                         prop->identifier = BLI_strdup(prop->identifier);
2873                 }
2874         }
2875
2876         if (prop->name) prop->name = BLI_strdup(prop->name);
2877         if (prop->description) prop->description = BLI_strdup(prop->description);
2878
2879         switch (prop->type) {
2880                 case PROP_BOOLEAN: {
2881                         BoolPropertyRNA *bprop = (BoolPropertyRNA*)prop;
2882
2883                         if (bprop->defaultarray) {
2884                                 iarray = MEM_callocN(sizeof(int)*prop->totarraylength, "RNA_def_property_store");
2885                                 memcpy(iarray, bprop->defaultarray, sizeof(int)*prop->totarraylength);
2886                                 bprop->defaultarray = iarray;
2887                         }
2888                         break;
2889                 }
2890                 case PROP_INT: {
2891                         IntPropertyRNA *iprop = (IntPropertyRNA*)prop;
2892
2893                         if (iprop->defaultarray) {
2894                                 iarray = MEM_callocN(sizeof(int)*prop->totarraylength, "RNA_def_property_store");
2895                                 memcpy(iarray, iprop->defaultarray, sizeof(int)*prop->totarraylength);
2896                                 iprop->defaultarray = iarray;
2897                         }
2898                         break;
2899                 }
2900                 case PROP_ENUM: {
2901                         EnumPropertyRNA *eprop = (EnumPropertyRNA*)prop;
2902
2903                         if (eprop->item) {
2904                                 earray = MEM_callocN(sizeof(EnumPropertyItem)*(eprop->totitem+1), "RNA_def_property_store"),
2905                                 memcpy(earray, eprop->item, sizeof(EnumPropertyItem)*(eprop->totitem+1));
2906                                 eprop->item = earray;
2907
2908                                 for (a = 0; a<eprop->totitem; a++) {
2909                                         if (eprop->item[a].identifier)
2910                                                 eprop->item[a].identifier = BLI_strdup(eprop->item[a].identifier);
2911                                         if (eprop->item[a].name)
2912                                                 eprop->item[a].name = BLI_strdup(eprop->item[a].name);
2913                                         if (eprop->item[a].description)
2914                                                 eprop->item[a].description = BLI_strdup(eprop->item[a].description);
2915                                 }
2916                         }
2917                         break;
2918                 }
2919                 case PROP_FLOAT: {
2920                         FloatPropertyRNA *fprop = (FloatPropertyRNA*)prop;
2921
2922                         if (fprop->defaultarray) {
2923                                 farray = MEM_callocN(sizeof(float)*prop->totarraylength, "RNA_def_property_store");
2924                                 memcpy(farray, fprop->defaultarray, sizeof(float)*prop->totarraylength);
2925                                 fprop->defaultarray = farray;
2926                         }
2927                         break;
2928                 }
2929                 case PROP_STRING: {
2930                         StringPropertyRNA *sprop = (StringPropertyRNA*)prop;
2931                         if (sprop->defaultvalue)
2932                                 sprop->defaultvalue = BLI_strdup(sprop->defaultvalue);
2933                         break;
2934                 }
2935                 default:
2936                         break;
2937         }
2938
2939         prop->flag |= PROP_FREE_POINTERS;
2940 }
2941
2942 void RNA_def_property_free_pointers(PropertyRNA *prop)
2943 {
2944         if (prop->flag & PROP_FREE_POINTERS) {
2945                 int a;
2946
2947                 if (prop->identifier)
2948                         MEM_freeN((void*)prop->identifier);
2949                 if (prop->name)
2950                         MEM_freeN((void*)prop->name);
2951                 if (prop->description)
2952                         MEM_freeN((void*)prop->description);
2953                 if (prop->py_data)
2954                         MEM_freeN(prop->py_data);
2955
2956                 switch (prop->type) {
2957                         case PROP_BOOLEAN: {
2958                                 BoolPropertyRNA *bprop = (BoolPropertyRNA*)prop;
2959                                 if (bprop->defaultarray)
2960                                         MEM_freeN((void*)bprop->defaultarray);
2961                                 break;
2962                         }
2963                         case PROP_INT: {
2964                                 IntPropertyRNA *iprop = (IntPropertyRNA*)prop;
2965                                 if (iprop->defaultarray)
2966                                         MEM_freeN((void*)iprop->defaultarray);
2967                                 break;
2968                         }
2969                         case PROP_FLOAT: {
2970                                 FloatPropertyRNA *fprop = (FloatPropertyRNA*)prop;
2971                                 if (fprop->defaultarray)
2972                                         MEM_freeN((void*)fprop->defaultarray);
2973                                 break;
2974                         }
2975                         case PROP_ENUM: {
2976                                 EnumPropertyRNA *eprop = (EnumPropertyRNA*)prop;
2977
2978                                 for (a = 0; a<eprop->totitem; a++) {
2979                                         if (eprop->item[a].identifier)
2980                                                 MEM_freeN((void*)eprop->item[a].identifier);
2981                                         if (eprop->item[a].name)
2982                                                 MEM_freeN((void*)eprop->item[a].name);
2983                                         if (eprop->item[a].description)
2984                                                 MEM_freeN((void*)eprop->item[a].description);
2985                                 }
2986
2987                                 if (eprop->item) MEM_freeN((void*)eprop->item);
2988                                 break;
2989                         }
2990                         case PROP_STRING: {
2991                                 StringPropertyRNA *sprop = (StringPropertyRNA*)prop;
2992                                 if (sprop->defaultvalue)
2993                                         MEM_freeN((void*)sprop->defaultvalue);
2994                                 break;
2995                         }
2996                         default:
2997                                 break;
2998                 }
2999         }
3000 }
3001
3002 static void rna_def_property_free(StructOrFunctionRNA *cont_, PropertyRNA *prop)
3003 {
3004         ContainerRNA *cont = cont_;
3005         
3006         if (prop->flag & PROP_RUNTIME) {
3007                 if (cont->prophash)
3008                         BLI_ghash_remove(cont->prophash, (void*)prop->identifier, NULL, NULL);
3009
3010                 RNA_def_property_free_pointers(prop);
3011                 rna_freelinkN(&cont->properties, prop);
3012         }
3013         else {
3014                 RNA_def_property_free_pointers(prop);
3015         }
3016 }
3017
3018 /* note: only intended for removing dynamic props */
3019 int RNA_def_property_free_identifier(StructOrFunctionRNA *cont_, const char *identifier)
3020 {
3021         ContainerRNA *cont = cont_;
3022         PropertyRNA *prop;
3023         
3024         for (prop = cont->properties.first; prop; prop = prop->next) {
3025                 if (strcmp(prop->identifier, identifier) == 0) {
3026                         if (prop->flag & PROP_RUNTIME) {
3027                                 rna_def_property_free(cont_, prop);
3028                                 return 1;
3029                         }
3030                         else {
3031                                 return -1;
3032                         }
3033                 }
3034         }
3035         return 0;
3036 }
3037 #endif
3038
3039 const char *RNA_property_typename(PropertyType type)
3040 {
3041         switch (type) {
3042                 case PROP_BOOLEAN: return "PROP_BOOLEAN";
3043                 case PROP_INT: return "PROP_INT";
3044                 case PROP_FLOAT: return "PROP_FLOAT";
3045                 case PROP_STRING: return "PROP_STRING";
3046                 case PROP_ENUM: return "PROP_ENUM";
3047                 case PROP_POINTER: return "PROP_POINTER";
3048                 case PROP_COLLECTION: return "PROP_COLLECTION";
3049         }
3050
3051         return "PROP_UNKNOWN";
3052 }