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