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