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