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