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