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