b08c4aeaed484f858b2bf755991ff900eb1cd069
[blender.git] / source / blender / makesrna / intern / rna_define.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * Contributor(s): Blender Foundation (2008).
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <float.h>
26 #include <limits.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <ctype.h>
31
32 #include "MEM_guardedalloc.h"
33
34 #include "DNA_genfile.h"
35 #include "DNA_sdna_types.h"
36
37 #include "RNA_access.h"
38 #include "RNA_define.h"
39 #include "RNA_types.h"
40
41 #include "rna_internal.h"
42
43 /* Global used during defining */
44
45 BlenderDefRNA DefRNA = {0, {0, 0}, {0, 0}, 0, 0, 0};
46
47 /* Duplicated code since we can't link in blenkernel or blenlib */
48
49 #ifndef MIN2
50 #define MIN2(x,y) ((x)<(y)? (x): (y))
51 #define MAX2(x,y) ((x)>(y)? (x): (y))
52 #endif
53
54 void rna_addtail(ListBase *listbase, void *vlink)
55 {
56         Link *link= vlink;
57
58         link->next = NULL;
59         link->prev = listbase->last;
60
61         if (listbase->last) ((Link *)listbase->last)->next = link;
62         if (listbase->first == 0) listbase->first = link;
63         listbase->last = link;
64 }
65
66 void rna_remlink(ListBase *listbase, void *vlink)
67 {
68         Link *link= vlink;
69
70         if (link->next) link->next->prev = link->prev;
71         if (link->prev) link->prev->next = link->next;
72
73         if (listbase->last == link) listbase->last = link->prev;
74         if (listbase->first == link) listbase->first = link->next;
75 }
76
77 void rna_freelinkN(ListBase *listbase, void *vlink)
78 {
79         rna_remlink(listbase, vlink);
80         MEM_freeN(vlink);
81 }
82
83 void rna_freelistN(ListBase *listbase)
84 {
85         Link *link, *next;
86         
87         for(link=listbase->first; link; link=next) {
88                 next= link->next;
89                 MEM_freeN(link);
90         }
91         
92         listbase->first= listbase->last= NULL;
93 }
94
95 /* DNA utility function for looking up members */
96
97 typedef struct DNAStructMember {
98         char *type;
99         char *name;
100         int arraylength;
101         int pointerlevel;
102 } DNAStructMember;
103
104 static int rna_member_cmp(const char *name, const char *oname)
105 {
106         int a=0;
107         
108         /* compare without pointer or array part */
109         while(name[0]=='*')
110                 name++;
111         while(oname[0]=='*')
112                 oname++;
113         
114         while(1) {
115                 if(name[a]=='[' && oname[a]==0) return 1;
116                 if(name[a]==0) break;
117                 if(name[a] != oname[a]) return 0;
118                 a++;
119         }
120         if(name[a]==0 && oname[a] == '.') return 2;
121         if(name[a]==0 && oname[a] == '-' && oname[a+1] == '>') return 3;
122
123         return (name[a] == oname[a]);
124 }
125
126 static int rna_find_sdna_member(SDNA *sdna, const char *structname, const char *membername, DNAStructMember *smember)
127 {
128         char *dnaname;
129         short *sp;
130         int a, b, structnr, totmember, cmp;
131
132         structnr= DNA_struct_find_nr(sdna, structname);
133         if(structnr == -1)
134                 return 0;
135
136         sp= sdna->structs[structnr];
137         totmember= sp[1];
138         sp+= 2;
139
140         for(a=0; a<totmember; a++, sp+=2) {
141                 dnaname= sdna->names[sp[1]];
142
143                 cmp= rna_member_cmp(dnaname, membername);
144
145                 if(cmp == 1) {
146                         smember->type= sdna->types[sp[0]];
147                         smember->name= dnaname;
148                         smember->arraylength= DNA_elem_array_size(smember->name, strlen(smember->name));
149
150                         smember->pointerlevel= 0;
151                         for(b=0; dnaname[b] == '*'; b++)
152                                 smember->pointerlevel++;
153
154                         return 1;
155                 }
156                 else if(cmp == 2) {
157                         membername= strstr(membername, ".") + strlen(".");
158                         return rna_find_sdna_member(sdna, sdna->types[sp[0]], membername, smember);
159                 }
160                 else if(cmp == 3) {
161                         membername= strstr(membername, "->") + strlen("->");
162                         return rna_find_sdna_member(sdna, sdna->types[sp[0]], membername, smember);
163                 }
164         }
165
166         return 0;
167 }
168
169 static int rna_validate_identifier(const char *identifier, char *error, int property)
170 {
171         int a=0;
172         
173         /*  list from http://docs.python.org/reference/lexical_analysis.html#id5 */
174         static char *kwlist[] = {
175                 "and", "as", "assert", "break",
176                 "class", "continue", "def", "del",
177                 "elif", "else", "except", "exec",
178                 "finally", "for", "from", "global",
179                 "if", "import", "in", "is",
180                 "lambda", "not", "or", "pass",
181                 "print", "raise", "return", "try",
182                 "while", "with", "yield", NULL
183         };
184         
185         
186         if (!isalpha(identifier[0])) {
187                 strcpy(error, "first character failed isalpha() check");
188                 return 0;
189         }
190         
191         for(a=0; identifier[a]; a++) {
192                 if(DefRNA.preprocess && property) {
193                         if(isalpha(identifier[a]) && isupper(identifier[a])) {
194                                 strcpy(error, "property names must contain lower case characters only");
195                                 return 0;
196                         }
197                 }
198                 
199                 if (identifier[a]=='_') {
200                         continue;
201                 }
202
203                 if (identifier[a]==' ') {
204                         strcpy(error, "spaces are not ok in identifier names");
205                         return 0;
206                 }
207
208                 if (isalnum(identifier[a])==0) {
209                         strcpy(error, "one of the characters failed an isalnum() check and is not an underscore");
210                         return 0;
211                 }
212         }
213         
214         for(a=0; kwlist[a]; a++) {
215                 if (strcmp(identifier, kwlist[a]) == 0) {
216                         strcpy(error, "this keyword is reserved by python");
217                         return 0;
218                 }
219         }
220         
221         return 1;
222 }
223
224 /* Blender Data Definition */
225
226 BlenderRNA *RNA_create()
227 {
228         BlenderRNA *brna;
229
230         brna= MEM_callocN(sizeof(BlenderRNA), "BlenderRNA");
231
232         DefRNA.sdna= DNA_sdna_from_data(DNAstr,  DNAlen, 0);
233         DefRNA.structs.first= DefRNA.structs.last= NULL;
234         DefRNA.error= 0;
235         DefRNA.preprocess= 1;
236
237         return brna;
238 }
239
240 void RNA_define_free(BlenderRNA *brna)
241 {
242         StructDefRNA *srna;
243         AllocDefRNA *alloc;
244
245         for(alloc=DefRNA.allocs.first; alloc; alloc=alloc->next)
246                 MEM_freeN(alloc->mem);
247         rna_freelistN(&DefRNA.allocs);
248
249         for(srna=DefRNA.structs.first; srna; srna=srna->next)
250                 rna_freelistN(&srna->properties);
251
252         rna_freelistN(&DefRNA.structs);
253
254         if(DefRNA.sdna) {
255                 DNA_sdna_free(DefRNA.sdna);
256                 DefRNA.sdna= NULL;
257         }
258
259         DefRNA.error= 0;
260 }
261
262 void RNA_free(BlenderRNA *brna)
263 {
264         StructRNA *srna, *nextsrna;
265         PropertyRNA *prop, *nextprop;
266
267         if(DefRNA.preprocess) {
268                 RNA_define_free(brna);
269
270                 for(srna=brna->structs.first; srna; srna=srna->next)
271                         rna_freelistN(&srna->properties);
272
273                 rna_freelistN(&brna->structs);
274                 
275                 MEM_freeN(brna);
276         }
277         else {
278                 for(srna=brna->structs.first; srna; srna=nextsrna) {
279                         nextsrna= srna->next;
280
281                         for(prop=srna->properties.first; prop; prop=nextprop) {
282                                 nextprop= prop->next;
283
284                                 if(prop->flag & PROP_RUNTIME)
285                                         rna_freelinkN(&srna->properties, prop);
286                         }
287
288                         if(srna->flag & STRUCT_RUNTIME)
289                                 rna_freelinkN(&brna->structs, srna);
290                 }
291         }
292 }
293
294 static size_t rna_property_type_sizeof(PropertyType type)
295 {
296         switch(type) {
297                 case PROP_BOOLEAN: return sizeof(BooleanPropertyRNA);
298                 case PROP_INT: return sizeof(IntPropertyRNA);
299                 case PROP_FLOAT: return sizeof(FloatPropertyRNA);
300                 case PROP_STRING: return sizeof(StringPropertyRNA);
301                 case PROP_ENUM: return sizeof(EnumPropertyRNA);
302                 case PROP_POINTER: return sizeof(PointerPropertyRNA);
303                 case PROP_COLLECTION: return sizeof(CollectionPropertyRNA);
304                 default: return 0;
305         }
306 }
307
308 static StructDefRNA *rna_find_def_struct(StructRNA *srna)
309 {
310         StructDefRNA *ds;
311
312         for(ds=DefRNA.structs.first; ds; ds=ds->next)
313                 if(ds->srna == srna)
314                         return ds;
315
316         return NULL;
317 }
318
319 /* Struct Definition */
320
321 StructRNA *RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *from)
322 {
323         StructRNA *srna, *srnafrom= NULL;
324         StructDefRNA *ds= NULL, *dsfrom= NULL;
325         PropertyRNA *prop;
326         
327         if(DefRNA.preprocess) {
328                 char error[512];
329
330                 if (rna_validate_identifier(identifier, error, 0) == 0) {
331                         fprintf(stderr, "RNA_def_struct: struct identifier \"%s\" error - %s\n", identifier, error);
332                         DefRNA.error= 1;
333                 }
334         }
335         
336         if(from) {
337                 /* find struct to derive from */
338                 for(srnafrom= brna->structs.first; srnafrom; srnafrom=srnafrom->next)
339                         if(strcmp(srnafrom->identifier, from) == 0)
340                                 break;
341
342                 if(!srnafrom) {
343                         fprintf(stderr, "RNA_def_struct: struct %s not found to define %s.\n", from, identifier);
344                         DefRNA.error= 1;
345                 }
346         }
347
348         srna= MEM_callocN(sizeof(StructRNA), "StructRNA");
349         DefRNA.laststruct= srna;
350
351         if(srnafrom) {
352                 /* copy from struct to derive stuff, a bit clumsy since we can't
353                  * use MEM_dupallocN, data structs may not be alloced but builtin */
354                 memcpy(srna, srnafrom, sizeof(StructRNA));
355                 srna->properties.first= srna->properties.last= NULL;
356
357                 if(DefRNA.preprocess) {
358                         srna->base= srnafrom;
359                         dsfrom= rna_find_def_struct(srnafrom);
360                 }
361                 else
362                         srna->base= srnafrom;
363         }
364
365         srna->identifier= identifier;
366         srna->name= identifier; /* may be overwritten later RNA_def_struct_ui_text */
367         srna->description= "";
368
369         rna_addtail(&brna->structs, srna);
370
371         if(DefRNA.preprocess) {
372                 ds= MEM_callocN(sizeof(StructDefRNA), "StructDefRNA");
373                 ds->srna= srna;
374                 rna_addtail(&DefRNA.structs, ds);
375
376                 if(dsfrom)
377                         ds->dnafromname= dsfrom->dnaname;
378         }
379
380         /* in preprocess, try to find sdna */
381         if(DefRNA.preprocess)
382                 RNA_def_struct_sdna(srna, srna->identifier);
383         else
384                 srna->flag |= STRUCT_RUNTIME;
385
386         if(srnafrom) {
387                 srna->nameproperty= srnafrom->nameproperty;
388                 srna->iteratorproperty= srnafrom->iteratorproperty;
389         }
390         else {
391                 /* define some builtin properties */
392                 prop= RNA_def_property(srna, "rna_properties", PROP_COLLECTION, PROP_NONE);
393                 RNA_def_property_flag(prop, PROP_BUILTIN);
394                 RNA_def_property_ui_text(prop, "Properties", "RNA property collection.");
395
396                 if(DefRNA.preprocess) {
397                         RNA_def_property_struct_type(prop, "Property");
398                         RNA_def_property_collection_funcs(prop, "rna_builtin_properties_begin", "rna_builtin_properties_next", "rna_iterator_listbase_end", "rna_builtin_properties_get", 0, 0, 0);
399                 }
400                 else {
401 #ifdef RNA_RUNTIME
402                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
403                         cprop->begin= rna_builtin_properties_begin;
404                         cprop->next= rna_builtin_properties_next;
405                         cprop->get= rna_builtin_properties_get;
406                         cprop->type= &RNA_Property;
407 #endif
408                 }
409
410                 prop= RNA_def_property(srna, "rna_type", PROP_POINTER, PROP_NONE);
411                 RNA_def_property_ui_text(prop, "RNA", "RNA type definition.");
412
413                 if(DefRNA.preprocess) {
414                         RNA_def_property_struct_type(prop, "Struct");
415                         RNA_def_property_pointer_funcs(prop, "rna_builtin_type_get", NULL);
416                 }
417                 else {
418 #ifdef RNA_RUNTIME
419                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
420                         pprop->get= rna_builtin_type_get;
421                         pprop->type= &RNA_Struct;
422 #endif
423                 }
424         }
425
426         return srna;
427 }
428
429 void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
430 {
431         StructDefRNA *ds= DefRNA.structs.last;
432
433         if(!DefRNA.preprocess) {
434                 fprintf(stderr, "RNA_def_struct_sdna: only during preprocessing.\n");
435                 return;
436         }
437
438         if(!DNA_struct_find_nr(DefRNA.sdna, structname)) {
439                 if(!DefRNA.silent) {
440                         fprintf(stderr, "RNA_def_struct_sdna: %s not found.\n", structname);
441                         DefRNA.error= 1;
442                 }
443                 return;
444         }
445
446         ds->dnaname= structname;
447 }
448
449 void RNA_def_struct_sdna_from(StructRNA *srna, const char *structname, const char *propname)
450 {
451         StructDefRNA *ds= DefRNA.structs.last;
452
453         if(!DefRNA.preprocess) {
454                 fprintf(stderr, "RNA_def_struct_sdna_from: only during preprocessing.\n");
455                 return;
456         }
457
458         if(!ds->dnaname) {
459                 fprintf(stderr, "RNA_def_struct_sdna_from: %s base struct must know DNA already.\n", structname);
460                 return;
461         }
462
463         if(!DNA_struct_find_nr(DefRNA.sdna, structname)) {
464                 if(!DefRNA.silent) {
465                         fprintf(stderr, "RNA_def_struct_sdna_from: %s not found.\n", structname);
466                         DefRNA.error= 1;
467                 }
468                 return;
469         }
470
471         ds->dnafromprop= propname;
472         ds->dnaname= structname;
473 }
474
475 void RNA_def_struct_name_property(struct StructRNA *srna, struct PropertyRNA *prop)
476 {
477         if(prop->type != PROP_STRING) {
478                 fprintf(stderr, "RNA_def_struct_name_property: %s.%s, must be a string property.\n", srna->identifier, prop->identifier);
479                 DefRNA.error= 1;
480         }
481         else
482                 srna->nameproperty= prop;
483 }
484
485 void RNA_def_struct_nested(BlenderRNA *brna, StructRNA *srna, const char *structname)
486 {
487         StructRNA *srnafrom;
488
489         /* find struct to derive from */
490         for(srnafrom= brna->structs.first; srnafrom; srnafrom=srnafrom->next)
491                 if(strcmp(srnafrom->identifier, structname) == 0)
492                         break;
493
494         if(!srnafrom) {
495                 fprintf(stderr, "RNA_def_struct_nested: struct %s not found.\n", structname);
496                 DefRNA.error= 1;
497         }
498
499         srna->nested= srnafrom;
500 }
501
502 void RNA_def_struct_flag(StructRNA *srna, int flag)
503 {
504         srna->flag= flag;
505 }
506
507 void RNA_def_struct_refine_func(StructRNA *srna, const char *refine)
508 {
509         if(!DefRNA.preprocess) {
510                 fprintf(stderr, "RNA_def_struct_refine_func: only during preprocessing.\n");
511                 return;
512         }
513
514         if(refine) srna->refine= (StructRefineFunc)refine;
515 }
516
517 void RNA_def_struct_identifier(StructRNA *srna, const char *identifier)
518 {
519         if(DefRNA.preprocess) {
520                 fprintf(stderr, "RNA_def_struct_name_runtime: only at runtime.\n");
521                 return;
522         }
523
524         srna->identifier= identifier;
525 }
526
527 void RNA_def_struct_ui_text(StructRNA *srna, const char *name, const char *description)
528 {
529         srna->name= name;
530         srna->description= description;
531 }
532
533 void RNA_struct_free(BlenderRNA *brna, StructRNA *srna)
534 {
535         rna_freelistN(&srna->properties);
536         rna_freelinkN(&brna->structs, srna);
537 }
538
539 /* Property Definition */
540
541 PropertyRNA *RNA_def_property(StructRNA *srna, const char *identifier, int type, int subtype)
542 {
543         StructDefRNA *ds;
544         PropertyDefRNA *dp= NULL;
545         PropertyRNA *prop;
546
547         if(DefRNA.preprocess) {
548                 char error[512];
549                 
550                 if (rna_validate_identifier(identifier, error, 1) == 0) {
551                         fprintf(stderr, "RNA_def_property: property identifier \"%s\" - %s\n", identifier, error);
552                         DefRNA.error= 1;
553                 }
554                 
555                 ds= DefRNA.structs.last;
556                 dp= MEM_callocN(sizeof(PropertyDefRNA), "PropertyDefRNA");
557                 rna_addtail(&ds->properties, dp);
558         }
559
560         prop= MEM_callocN(rna_property_type_sizeof(type), "PropertyRNA");
561
562         switch(type) {
563                 case PROP_BOOLEAN:
564                         break;
565                 case PROP_INT: {
566                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
567
568                         iprop->hardmin= (subtype == PROP_UNSIGNED)? 0: INT_MIN;
569                         iprop->hardmax= INT_MAX;
570
571                         iprop->softmin= (subtype == PROP_UNSIGNED)? 0: -10000; /* rather arbitrary .. */
572                         iprop->softmax= 10000;
573                         iprop->step= 1;
574                         break;
575                 }
576                 case PROP_FLOAT: {
577                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
578
579                         fprop->hardmin= (subtype == PROP_UNSIGNED)? 0.0f: -FLT_MAX;
580                         fprop->hardmax= FLT_MAX;
581
582                         if(subtype == PROP_COLOR) {
583                                 fprop->softmin= 0.0f;
584                                 fprop->softmax= 1.0f;
585                         }
586                         else if(subtype == PROP_PERCENTAGE) {
587                                 fprop->softmin= fprop->hardmin= 0.0f;
588                                 fprop->softmax= fprop->hardmax= 1.0f;
589                         }
590                         else {
591                                 fprop->softmin= (subtype == PROP_UNSIGNED)? 0.0f: -10000.0f; /* rather arbitrary .. */
592                                 fprop->softmax= 10000.0f;
593                         }
594                         fprop->step= 10;
595                         fprop->precision= 3;
596                         break;
597                 }
598                 case PROP_STRING: {
599                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
600
601                         sprop->defaultvalue= "";
602                         sprop->maxlength= 0;
603                         break;
604                 }
605                 case PROP_ENUM:
606                 case PROP_POINTER:
607                 case PROP_COLLECTION:
608                         break;
609                 default:
610                         fprintf(stderr, "RNA_def_property: %s.%s, invalid property type.\n", srna->identifier, identifier);
611                         DefRNA.error= 1;
612                         return NULL;
613         }
614
615         if(DefRNA.preprocess) {
616                 dp->srna= srna;
617                 dp->prop= prop;
618         }
619
620         prop->magic= RNA_MAGIC;
621         prop->identifier= identifier;
622         prop->type= type;
623         prop->subtype= subtype;
624         prop->name= identifier;
625         prop->description= "";
626
627         if(type != PROP_COLLECTION && type != PROP_POINTER)
628                 prop->flag= PROP_EDITABLE|PROP_ANIMATEABLE;
629
630         if(DefRNA.preprocess) {
631                 switch(type) {
632                         case PROP_BOOLEAN:
633                                 DefRNA.silent= 1;
634                                 RNA_def_property_boolean_sdna(prop, NULL, identifier, 0);
635                                 DefRNA.silent= 0;
636                                 break;
637                         case PROP_INT: {
638                                 DefRNA.silent= 1;
639                                 RNA_def_property_int_sdna(prop, NULL, identifier);
640                                 DefRNA.silent= 0;
641                                 break;
642                         }
643                         case PROP_FLOAT: {
644                                 DefRNA.silent= 1;
645                                 RNA_def_property_float_sdna(prop, NULL, identifier);
646                                 DefRNA.silent= 0;
647                                 break;
648                         }
649                         case PROP_STRING: {
650                                 DefRNA.silent= 1;
651                                 RNA_def_property_string_sdna(prop, NULL, identifier);
652                                 DefRNA.silent= 0;
653                                 break;
654                         }
655                         case PROP_ENUM:
656                                 DefRNA.silent= 1;
657                                 RNA_def_property_enum_sdna(prop, NULL, identifier);
658                                 DefRNA.silent= 0;
659                                 break;
660                         case PROP_POINTER:
661                                 DefRNA.silent= 1;
662                                 RNA_def_property_pointer_sdna(prop, NULL, identifier);
663                                 DefRNA.silent= 0;
664                                 break;
665                         case PROP_COLLECTION:
666                                 DefRNA.silent= 1;
667                                 RNA_def_property_collection_sdna(prop, NULL, identifier, NULL);
668                                 DefRNA.silent= 0;
669                                 break;
670                 }
671         }
672         else
673                 prop->flag |= PROP_IDPROPERTY|PROP_RUNTIME;
674
675         rna_addtail(&srna->properties, prop);
676
677         return prop;
678 }
679
680 void RNA_def_property_flag(PropertyRNA *prop, int flag)
681 {
682         prop->flag |= flag;
683 }
684
685 void RNA_def_property_clear_flag(PropertyRNA *prop, int flag)
686 {
687         prop->flag &= ~flag;
688 }
689
690 void RNA_def_property_array(PropertyRNA *prop, int arraylength)
691 {
692         StructRNA *srna= DefRNA.laststruct;
693
694         if(arraylength<0) {
695                 fprintf(stderr, "RNA_def_property_array: %s.%s, array length must be zero of greater.\n", srna->identifier, prop->identifier);
696                 DefRNA.error= 1;
697                 return;
698         }
699
700         if(arraylength>RNA_MAX_ARRAY) {
701                 fprintf(stderr, "RNA_def_property_array: %s.%s, array length must be smaller than %d.\n", srna->identifier, prop->identifier, RNA_MAX_ARRAY);
702                 DefRNA.error= 1;
703                 return;
704         }
705
706         switch(prop->type) {
707                 case PROP_BOOLEAN:
708                 case PROP_INT:
709                 case PROP_FLOAT:
710                         prop->arraylength= arraylength;
711                         break;
712                 default:
713                         fprintf(stderr, "RNA_def_property_array: %s.%s, only boolean/int/float can be array.\n", srna->identifier, prop->identifier);
714                         DefRNA.error= 1;
715                         break;
716         }
717 }
718
719 void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description)
720 {
721         prop->name= name;
722         prop->description= description;
723 }
724
725 void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
726 {
727         StructRNA *srna= DefRNA.laststruct;
728
729         switch(prop->type) {
730                 case PROP_INT: {
731                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
732                         iprop->softmin= (int)min;
733                         iprop->softmax= (int)max;
734                         iprop->step= (int)step;
735                         break;
736                 }
737                 case PROP_FLOAT: {
738                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
739                         fprop->softmin= (float)min;
740                         fprop->softmax= (float)max;
741                         fprop->step= (float)step;
742                         fprop->precision= (int)precision;
743                         break;
744                 }
745                 default:
746                         fprintf(stderr, "RNA_def_property_ui_range: %s.%s, invalid type for ui range.\n", srna->identifier, prop->identifier);
747                         DefRNA.error= 1;
748                         break;
749         }
750 }
751
752 void RNA_def_property_range(PropertyRNA *prop, double min, double max)
753 {
754         StructRNA *srna= DefRNA.laststruct;
755
756         switch(prop->type) {
757                 case PROP_INT: {
758                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
759                         iprop->hardmin= (int)min;
760                         iprop->hardmax= (int)max;
761                         iprop->softmin= MAX2((int)min, iprop->hardmin);
762                         iprop->softmax= MIN2((int)max, iprop->hardmax);
763                         break;
764                 }
765                 case PROP_FLOAT: {
766                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
767                         fprop->hardmin= (float)min;
768                         fprop->hardmax= (float)max;
769                         fprop->softmin= MAX2((float)min, fprop->hardmin);
770                         fprop->softmax= MIN2((float)max, fprop->hardmax);
771                         break;
772                 }
773                 default:
774                         fprintf(stderr, "RNA_def_property_range: %s.%s, invalid type for range.\n", srna->identifier, prop->identifier);
775                         DefRNA.error= 1;
776                         break;
777         }
778 }
779
780 void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
781 {
782         StructRNA *srna= DefRNA.laststruct;
783
784         if(!DefRNA.preprocess) {
785                 fprintf(stderr, "RNA_def_property_struct_type: only during preprocessing.\n");
786                 return;
787         }
788
789         switch(prop->type) {
790                 case PROP_POINTER: {
791                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
792                         pprop->type = (StructRNA*)type;
793                         break;
794                 }
795                 case PROP_COLLECTION: {
796                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
797                         cprop->type = (StructRNA*)type;
798                         break;
799                 }
800                 default:
801                         fprintf(stderr, "RNA_def_property_struct_type: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
802                         DefRNA.error= 1;
803                         break;
804         }
805 }
806
807 void RNA_def_property_struct_runtime(PropertyRNA *prop, StructRNA *type)
808 {
809         StructRNA *srna= DefRNA.laststruct;
810
811         if(DefRNA.preprocess) {
812                 fprintf(stderr, "RNA_def_property_struct_runtime: only at runtime.\n");
813                 return;
814         }
815
816         switch(prop->type) {
817                 case PROP_POINTER: {
818                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
819                         pprop->type = type;
820                         break;
821                 }
822                 case PROP_COLLECTION: {
823                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
824                         cprop->type = type;
825                         break;
826                 }
827                 default:
828                         fprintf(stderr, "RNA_def_property_struct_runtime: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
829                         DefRNA.error= 1;
830                         break;
831         }
832 }
833
834 void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item)
835 {
836         StructRNA *srna= DefRNA.laststruct;
837         int i, defaultfound= 0;
838
839         switch(prop->type) {
840                 case PROP_ENUM: {
841                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
842                         eprop->item= item;
843                         eprop->totitem= 0;
844                         for(i=0; item[i].identifier; i++) {
845                                 eprop->totitem++;
846
847                                 if(item[i].value == eprop->defaultvalue)
848                                         defaultfound= 1;
849                         }
850
851                         if(!defaultfound)
852                                 eprop->defaultvalue= item[0].value;
853
854                         break;
855                 }
856                 default:
857                         fprintf(stderr, "RNA_def_property_enum_items: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
858                         DefRNA.error= 1;
859                         break;
860         }
861 }
862
863 void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
864 {
865         StructRNA *srna= DefRNA.laststruct;
866
867         switch(prop->type) {
868                 case PROP_STRING: {
869                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
870                         sprop->maxlength= maxlength;
871                         break;
872                 }
873                 default:
874                         fprintf(stderr, "RNA_def_property_string_maxlength: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
875                         DefRNA.error= 1;
876                         break;
877         }
878 }
879
880 void RNA_def_property_boolean_default(PropertyRNA *prop, int value)
881 {
882         StructRNA *srna= DefRNA.laststruct;
883
884         switch(prop->type) {
885                 case PROP_BOOLEAN: {
886                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
887                         bprop->defaultvalue= value;
888                         break;
889                 }
890                 default:
891                         fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
892                         DefRNA.error= 1;
893                         break;
894         }
895 }
896
897 void RNA_def_property_boolean_array_default(PropertyRNA *prop, const int *array)
898 {
899         StructRNA *srna= DefRNA.laststruct;
900
901         switch(prop->type) {
902                 case PROP_BOOLEAN: {
903                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
904                         bprop->defaultarray= array;
905                         break;
906                 }
907                 default:
908                         fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
909                         DefRNA.error= 1;
910                         break;
911         }
912 }
913
914 void RNA_def_property_int_default(PropertyRNA *prop, int value)
915 {
916         StructRNA *srna= DefRNA.laststruct;
917
918         switch(prop->type) {
919                 case PROP_INT: {
920                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
921                         iprop->defaultvalue= value;
922                         break;
923                 }
924                 default:
925                         fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
926                         DefRNA.error= 1;
927                         break;
928         }
929 }
930
931 void RNA_def_property_int_array_default(PropertyRNA *prop, const int *array)
932 {
933         StructRNA *srna= DefRNA.laststruct;
934
935         switch(prop->type) {
936                 case PROP_INT: {
937                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
938                         iprop->defaultarray= array;
939                         break;
940                 }
941                 default:
942                         fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
943                         DefRNA.error= 1;
944                         break;
945         }
946 }
947
948 void RNA_def_property_float_default(PropertyRNA *prop, float value)
949 {
950         StructRNA *srna= DefRNA.laststruct;
951
952         switch(prop->type) {
953                 case PROP_FLOAT: {
954                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
955                         fprop->defaultvalue= value;
956                         break;
957                 }
958                 default:
959                         fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
960                         DefRNA.error= 1;
961                         break;
962         }
963 }
964 /* array must remain valid after this function finishes */
965 void RNA_def_property_float_array_default(PropertyRNA *prop, const float *array)
966 {
967         StructRNA *srna= DefRNA.laststruct;
968
969         switch(prop->type) {
970                 case PROP_FLOAT: {
971                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
972                         fprop->defaultarray= array; /* WARNING, this array must not come from the stack and lost */
973                         break;
974                 }
975                 default:
976                         fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
977                         DefRNA.error= 1;
978                         break;
979         }
980 }
981
982 void RNA_def_property_string_default(PropertyRNA *prop, const char *value)
983 {
984         StructRNA *srna= DefRNA.laststruct;
985
986         switch(prop->type) {
987                 case PROP_STRING: {
988                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
989                         sprop->defaultvalue= value;
990                         break;
991                 }
992                 default:
993                         fprintf(stderr, "RNA_def_property_string_default: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
994                         DefRNA.error= 1;
995                         break;
996         }
997 }
998
999 void RNA_def_property_enum_default(PropertyRNA *prop, int value)
1000 {
1001         StructRNA *srna= DefRNA.laststruct;
1002         int i, defaultfound= 0;
1003
1004         switch(prop->type) {
1005                 case PROP_ENUM: {
1006                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
1007                         eprop->defaultvalue= value;
1008
1009                         for(i=0; i<eprop->totitem; i++) {
1010                                 if(eprop->item[i].value == eprop->defaultvalue)
1011                                         defaultfound= 1;
1012                         }
1013
1014                         if(!defaultfound && eprop->totitem) {
1015                                 if(value == 0) {
1016                                         eprop->defaultvalue= eprop->item[0].value;
1017                                 }
1018                                 else {
1019                                         fprintf(stderr, "RNA_def_property_enum_default: %s.%s, default is not in items.\n", srna->identifier, prop->identifier);
1020                                         DefRNA.error= 1;
1021                                 }
1022                         }
1023
1024                         break;
1025                 }
1026                 default:
1027                         fprintf(stderr, "RNA_def_property_enum_default: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
1028                         DefRNA.error= 1;
1029                         break;
1030         }
1031 }
1032
1033 /* SDNA */
1034
1035 static PropertyDefRNA *rna_def_property_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1036 {
1037         DNAStructMember smember;
1038         StructDefRNA *ds= DefRNA.structs.last;
1039         PropertyDefRNA *dp= ds->properties.last;
1040
1041         if(!structname)
1042                 structname= ds->dnaname;
1043         if(!propname)
1044                 propname= prop->identifier;
1045
1046         if(!rna_find_sdna_member(DefRNA.sdna, structname, propname, &smember)) {
1047                 if(!DefRNA.silent) {
1048                         fprintf(stderr, "rna_def_property_sdna: %s.%s not found.\n", structname, propname);
1049                         DefRNA.error= 1;
1050                 }
1051                 return NULL;
1052         }
1053
1054         if(smember.arraylength > 1)
1055                 prop->arraylength= smember.arraylength;
1056         else
1057                 prop->arraylength= 0;
1058         
1059         dp->dnastructname= structname;
1060         dp->dnastructfromname= ds->dnafromname;
1061         dp->dnastructfromprop= ds->dnafromprop;
1062         dp->dnaname= propname;
1063         dp->dnatype= smember.type;
1064         dp->dnaarraylength= smember.arraylength;
1065         dp->dnapointerlevel= smember.pointerlevel;
1066
1067         return dp;
1068 }
1069
1070 void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int bit)
1071 {
1072         PropertyDefRNA *dp;
1073         StructRNA *srna= DefRNA.laststruct;
1074         
1075         if(!DefRNA.preprocess) {
1076                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1077                 return;
1078         }
1079
1080         if(prop->type != PROP_BOOLEAN) {
1081                 fprintf(stderr, "RNA_def_property_boolean_sdna: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
1082                 DefRNA.error= 1;
1083                 return;
1084         }
1085
1086         if((dp=rna_def_property_sdna(prop, structname, propname)))
1087                 dp->booleanbit= bit;
1088 }
1089
1090 void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname, const char *propname, int booleanbit)
1091 {
1092         StructDefRNA *ds;
1093         PropertyDefRNA *dp;
1094
1095         RNA_def_property_boolean_sdna(prop, structname, propname, booleanbit);
1096
1097         if((ds=DefRNA.structs.last) && (dp=ds->properties.last))
1098                 dp->booleannegative= 1;
1099 }
1100
1101 void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1102 {
1103         PropertyDefRNA *dp;
1104         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
1105         StructRNA *srna= DefRNA.laststruct;
1106         
1107         if(!DefRNA.preprocess) {
1108                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1109                 return;
1110         }
1111
1112         if(prop->type != PROP_INT) {
1113                 fprintf(stderr, "RNA_def_property_int_sdna: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
1114                 DefRNA.error= 1;
1115                 return;
1116         }
1117
1118         if((dp= rna_def_property_sdna(prop, structname, propname))) {
1119                 /* SDNA doesn't pass us unsigned unfortunately .. */
1120                 if(strcmp(dp->dnatype, "char") == 0) {
1121                         iprop->hardmin= iprop->softmin= CHAR_MIN;
1122                         iprop->hardmax= iprop->softmax= CHAR_MAX;
1123                 }
1124                 else if(strcmp(dp->dnatype, "short") == 0) {
1125                         iprop->hardmin= iprop->softmin= SHRT_MIN;
1126                         iprop->hardmax= iprop->softmax= SHRT_MAX;
1127                 }
1128                 else if(strcmp(dp->dnatype, "int") == 0) {
1129                         iprop->hardmin= INT_MIN;
1130                         iprop->hardmax= INT_MAX;
1131
1132                         iprop->softmin= -10000; /* rather arbitrary .. */
1133                         iprop->softmax= 10000;
1134                 }
1135
1136                 if(prop->subtype == PROP_UNSIGNED)
1137                         iprop->hardmin= iprop->softmin= 0;
1138         }
1139 }
1140
1141 void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1142 {
1143         StructRNA *srna= DefRNA.laststruct;
1144
1145         if(!DefRNA.preprocess) {
1146                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1147                 return;
1148         }
1149
1150         if(prop->type != PROP_FLOAT) {
1151                 fprintf(stderr, "RNA_def_property_float_sdna: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
1152                 DefRNA.error= 1;
1153                 return;
1154         }
1155
1156         rna_def_property_sdna(prop, structname, propname);
1157 }
1158
1159 void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1160 {
1161         PropertyDefRNA *dp;
1162         StructRNA *srna= DefRNA.laststruct;
1163         
1164         if(!DefRNA.preprocess) {
1165                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1166                 return;
1167         }
1168
1169         if(prop->type != PROP_ENUM) {
1170                 fprintf(stderr, "RNA_def_property_enum_sdna: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
1171                 DefRNA.error= 1;
1172                 return;
1173         }
1174
1175         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1176                 if(prop->arraylength) {
1177                         prop->arraylength= 0;
1178                         if(!DefRNA.silent) {
1179                                 fprintf(stderr, "RNA_def_property_enum_sdna: %s.%s, array not supported for enum type.\n", structname, propname);
1180                                 DefRNA.error= 1;
1181                         }
1182                 }
1183         }
1184 }
1185
1186 void RNA_def_property_enum_bitflag_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1187 {
1188         StructDefRNA *ds;
1189         PropertyDefRNA *dp;
1190
1191         RNA_def_property_enum_sdna(prop, structname, propname);
1192
1193         if((ds=DefRNA.structs.last) && (dp=ds->properties.last))
1194                 dp->enumbitflags= 1;
1195 }
1196
1197 void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1198 {
1199         PropertyDefRNA *dp;
1200         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
1201         StructRNA *srna= DefRNA.laststruct;
1202
1203         if(!DefRNA.preprocess) {
1204                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1205                 return;
1206         }
1207
1208         if(prop->type != PROP_STRING) {
1209                 fprintf(stderr, "RNA_def_property_string_sdna: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
1210                 DefRNA.error= 1;
1211                 return;
1212         }
1213
1214         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1215                 if(prop->arraylength) {
1216                         sprop->maxlength= prop->arraylength;
1217                         prop->arraylength= 0;
1218                 }
1219         }
1220 }
1221
1222 void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1223 {
1224         PropertyDefRNA *dp;
1225         StructRNA *srna= DefRNA.laststruct;
1226         
1227         if(!DefRNA.preprocess) {
1228                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1229                 return;
1230         }
1231
1232         if(prop->type != PROP_POINTER) {
1233                 fprintf(stderr, "RNA_def_property_pointer_sdna: %s.%s, type is not pointer.\n", srna->identifier, prop->identifier);
1234                 DefRNA.error= 1;
1235                 return;
1236         }
1237
1238         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1239                 if(prop->arraylength) {
1240                         prop->arraylength= 0;
1241                         if(!DefRNA.silent) {
1242                                 fprintf(stderr, "RNA_def_property_pointer_sdna: %s.%s, array not supported for pointer type.\n", structname, propname);
1243                                 DefRNA.error= 1;
1244                         }
1245                 }
1246         }
1247 }
1248
1249 void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname, const char *lengthpropname)
1250 {
1251         PropertyDefRNA *dp;
1252         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
1253         StructRNA *srna= DefRNA.laststruct;
1254
1255         if(!DefRNA.preprocess) {
1256                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1257                 return;
1258         }
1259
1260         if(prop->type != PROP_COLLECTION) {
1261                 fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s, type is not collection.\n", srna->identifier, prop->identifier);
1262                 DefRNA.error= 1;
1263                 return;
1264         }
1265
1266         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1267                 if(prop->arraylength && !lengthpropname) {
1268                         prop->arraylength= 0;
1269
1270                         if(!DefRNA.silent) {
1271                                 fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s, array of collections not supported.\n", structname, propname);
1272                                 DefRNA.error= 1;
1273                         }
1274                 }
1275
1276                 if(strcmp(dp->dnatype, "ListBase") == 0) {
1277                         cprop->next= (PropCollectionNextFunc)"rna_iterator_listbase_next";
1278                         cprop->get= (PropCollectionGetFunc)"rna_iterator_listbase_get";
1279                         cprop->end= (PropCollectionEndFunc)"rna_iterator_listbase_end";
1280                 }
1281         }
1282
1283         if(dp && lengthpropname) {
1284                 DNAStructMember smember;
1285                 StructDefRNA *ds= DefRNA.structs.last;
1286
1287                 if(!structname)
1288                         structname= ds->dnaname;
1289
1290                 if(lengthpropname[0] == 0 || rna_find_sdna_member(DefRNA.sdna, structname, lengthpropname, &smember)) {
1291                         if(lengthpropname[0] == 0) {
1292                                 dp->dnalengthfixed= prop->arraylength;
1293                                 prop->arraylength= 0;
1294                         }
1295                         else {
1296                                 dp->dnalengthstructname= structname;
1297                                 dp->dnalengthname= lengthpropname;
1298                         }
1299
1300                         cprop->next= (PropCollectionNextFunc)"rna_iterator_array_next";
1301                         cprop->end= (PropCollectionEndFunc)"rna_iterator_array_end";
1302
1303                         if(dp->dnapointerlevel >= 2) 
1304                                 cprop->get= (PropCollectionGetFunc)"rna_iterator_array_dereference_get";
1305                         else
1306                                 cprop->get= (PropCollectionGetFunc)"rna_iterator_array_get";
1307                 }
1308                 else {
1309                         if(!DefRNA.silent) {
1310                                 fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s not found.\n", structname, lengthpropname);
1311                                 DefRNA.error= 1;
1312                         }
1313                 }
1314         }
1315 }
1316
1317 /* Functions */
1318
1319 void RNA_def_property_editable_func(PropertyRNA *prop, const char *editable)
1320 {
1321         if(!DefRNA.preprocess) {
1322                 fprintf(stderr, "RNA_def_property_editable_func: only during preprocessing.\n");
1323                 return;
1324         }
1325
1326         if(editable) prop->editable= (EditableFunc)editable;
1327 }
1328
1329 void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *func)
1330 {
1331         if(!DefRNA.preprocess) {
1332                 fprintf(stderr, "RNA_def_struct_refine_func: only during preprocessing.\n");
1333                 return;
1334         }
1335
1336         prop->noteflag= noteflag;
1337         prop->update= (UpdateFunc)func;
1338 }
1339
1340 void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
1341 {
1342         StructRNA *srna= DefRNA.laststruct;
1343
1344         if(!DefRNA.preprocess) {
1345                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1346                 return;
1347         }
1348
1349         switch(prop->type) {
1350                 case PROP_BOOLEAN: {
1351                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
1352
1353                         if(prop->arraylength) {
1354                                 if(get) bprop->getarray= (PropBooleanArrayGetFunc)get;
1355                                 if(set) bprop->setarray= (PropBooleanArraySetFunc)set;
1356                         }
1357                         else {
1358                                 if(get) bprop->get= (PropBooleanGetFunc)get;
1359                                 if(set) bprop->set= (PropBooleanSetFunc)set;
1360                         }
1361                         break;
1362                 }
1363                 default:
1364                         fprintf(stderr, "RNA_def_property_boolean_funcs: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
1365                         DefRNA.error= 1;
1366                         break;
1367         }
1368 }
1369
1370 void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
1371 {
1372         StructRNA *srna= DefRNA.laststruct;
1373
1374         if(!DefRNA.preprocess) {
1375                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1376                 return;
1377         }
1378
1379         switch(prop->type) {
1380                 case PROP_INT: {
1381                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
1382
1383                         if(prop->arraylength) {
1384                                 if(get) iprop->getarray= (PropIntArrayGetFunc)get;
1385                                 if(set) iprop->setarray= (PropIntArraySetFunc)set;
1386                         }
1387                         else {
1388                                 if(get) iprop->get= (PropIntGetFunc)get;
1389                                 if(set) iprop->set= (PropIntSetFunc)set;
1390                         }
1391                         if(range) iprop->range= (PropIntRangeFunc)range;
1392                         break;
1393                 }
1394                 default:
1395                         fprintf(stderr, "RNA_def_property_int_funcs: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
1396                         DefRNA.error= 1;
1397                         break;
1398         }
1399 }
1400
1401 void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
1402 {
1403         StructRNA *srna= DefRNA.laststruct;
1404
1405         if(!DefRNA.preprocess) {
1406                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1407                 return;
1408         }
1409
1410         switch(prop->type) {
1411                 case PROP_FLOAT: {
1412                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
1413
1414                         if(prop->arraylength) {
1415                                 if(get) fprop->getarray= (PropFloatArrayGetFunc)get;
1416                                 if(set) fprop->setarray= (PropFloatArraySetFunc)set;
1417                         }
1418                         else {
1419                                 if(get) fprop->get= (PropFloatGetFunc)get;
1420                                 if(set) fprop->set= (PropFloatSetFunc)set;
1421                         }
1422                         if(range) fprop->range= (PropFloatRangeFunc)range;
1423                         break;
1424                 }
1425                 default:
1426                         fprintf(stderr, "RNA_def_property_float_funcs: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
1427                         DefRNA.error= 1;
1428                         break;
1429         }
1430 }
1431
1432 void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char *set)
1433 {
1434         StructRNA *srna= DefRNA.laststruct;
1435
1436         if(!DefRNA.preprocess) {
1437                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1438                 return;
1439         }
1440
1441         switch(prop->type) {
1442                 case PROP_ENUM: {
1443                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
1444
1445                         if(get) eprop->get= (PropEnumGetFunc)get;
1446                         if(set) eprop->set= (PropEnumSetFunc)set;
1447                         break;
1448                 }
1449                 default:
1450                         fprintf(stderr, "RNA_def_property_enum_funcs: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
1451                         DefRNA.error= 1;
1452                         break;
1453         }
1454 }
1455
1456 void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
1457 {
1458         StructRNA *srna= DefRNA.laststruct;
1459
1460         if(!DefRNA.preprocess) {
1461                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1462                 return;
1463         }
1464
1465         switch(prop->type) {
1466                 case PROP_STRING: {
1467                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
1468
1469                         if(get) sprop->get= (PropStringGetFunc)get;
1470                         if(length) sprop->length= (PropStringLengthFunc)length;
1471                         if(set) sprop->set= (PropStringSetFunc)set;
1472                         break;
1473                 }
1474                 default:
1475                         fprintf(stderr, "RNA_def_property_string_funcs: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
1476                         DefRNA.error= 1;
1477                         break;
1478         }
1479 }
1480
1481 void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set)
1482 {
1483         StructRNA *srna= DefRNA.laststruct;
1484
1485         if(!DefRNA.preprocess) {
1486                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1487                 return;
1488         }
1489
1490         switch(prop->type) {
1491                 case PROP_POINTER: {
1492                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
1493
1494                         if(get) pprop->get= (PropPointerGetFunc)get;
1495                         if(set) pprop->set= (PropPointerSetFunc)set;
1496                         break;
1497                 }
1498                 default:
1499                         fprintf(stderr, "RNA_def_property_pointer_funcs: %s.%s, type is not pointer.\n", srna->identifier, prop->identifier);
1500                         DefRNA.error= 1;
1501                         break;
1502         }
1503 }
1504
1505 void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, const char *next, const char *end, const char *get, const char *length, const char *lookupint, const char *lookupstring)
1506 {
1507         StructRNA *srna= DefRNA.laststruct;
1508
1509         if(!DefRNA.preprocess) {
1510                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1511                 return;
1512         }
1513
1514         switch(prop->type) {
1515                 case PROP_COLLECTION: {
1516                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
1517
1518                         if(begin) cprop->begin= (PropCollectionBeginFunc)begin;
1519                         if(next) cprop->next= (PropCollectionNextFunc)next;
1520                         if(end) cprop->end= (PropCollectionEndFunc)end;
1521                         if(get) cprop->get= (PropCollectionGetFunc)get;
1522                         if(length) cprop->length= (PropCollectionLengthFunc)length;
1523                         if(lookupint) cprop->lookupint= (PropCollectionLookupIntFunc)lookupint;
1524                         if(lookupstring) cprop->lookupstring= (PropCollectionLookupStringFunc)lookupstring;
1525                         break;
1526                 }
1527                 default:
1528                         fprintf(stderr, "RNA_def_property_collection_funcs: %s.%s, type is not collection.\n", srna->identifier, prop->identifier);
1529                         DefRNA.error= 1;
1530                         break;
1531         }
1532 }
1533
1534 /* Compact definitions */
1535
1536 PropertyRNA *RNA_def_boolean(StructRNA *srna, const char *identifier, int default_value,
1537         const char *ui_name, const char *ui_description)
1538 {
1539         PropertyRNA *prop;
1540         
1541         prop= RNA_def_property(srna, identifier, PROP_BOOLEAN, PROP_NONE);
1542         RNA_def_property_boolean_default(prop, default_value);
1543         RNA_def_property_ui_text(prop, ui_name, ui_description);
1544
1545         return prop;
1546 }
1547
1548 PropertyRNA *RNA_def_boolean_array(StructRNA *srna, const char *identifier, int len, int *default_value, const char *ui_name, const char *ui_description)
1549 {
1550         PropertyRNA *prop;
1551         
1552         prop= RNA_def_property(srna, identifier, PROP_BOOLEAN, PROP_NONE);
1553         if(len != 0) RNA_def_property_array(prop, len);
1554         if(default_value) RNA_def_property_boolean_array_default(prop, default_value);
1555         RNA_def_property_ui_text(prop, ui_name, ui_description);
1556
1557         return prop;
1558 }
1559
1560 PropertyRNA *RNA_def_boolean_vector(StructRNA *srna, const char *identifier, int len, int *default_value, const char *ui_name, const char *ui_description)
1561 {
1562         PropertyRNA *prop;
1563         
1564         prop= RNA_def_property(srna, identifier, PROP_BOOLEAN, PROP_VECTOR);
1565         if(len != 0) RNA_def_property_array(prop, len);
1566         if(default_value) RNA_def_property_boolean_array_default(prop, default_value);
1567         RNA_def_property_ui_text(prop, ui_name, ui_description);
1568
1569         return prop;
1570 }
1571
1572 PropertyRNA *RNA_def_int(StructRNA *srna, const char *identifier, int default_value, int hardmin, int hardmax,
1573         const char *ui_name, const char *ui_description, int softmin, int softmax)
1574 {
1575         PropertyRNA *prop;
1576         
1577         prop= RNA_def_property(srna, identifier, PROP_INT, PROP_NONE);
1578         RNA_def_property_int_default(prop, default_value);
1579         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1580         RNA_def_property_ui_text(prop, ui_name, ui_description);
1581         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1582
1583         return prop;
1584 }
1585
1586 PropertyRNA *RNA_def_int_vector(StructRNA *srna, const char *identifier, int len, const int *default_value,
1587         int hardmin, int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
1588 {
1589         PropertyRNA *prop;
1590         
1591         prop= RNA_def_property(srna, identifier, PROP_INT, PROP_VECTOR);
1592         if(len != 0) RNA_def_property_array(prop, len);
1593         if(default_value) RNA_def_property_int_array_default(prop, default_value);
1594         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1595         RNA_def_property_ui_text(prop, ui_name, ui_description);
1596         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1597
1598         return prop;
1599 }
1600
1601 PropertyRNA *RNA_def_int_array(StructRNA *srna, const char *identifier, int len, const int *default_value,
1602         int hardmin, int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
1603 {
1604         PropertyRNA *prop;
1605         
1606         prop= RNA_def_property(srna, identifier, PROP_INT, PROP_NONE);
1607         if(len != 0) RNA_def_property_array(prop, len);
1608         if(default_value) RNA_def_property_int_array_default(prop, default_value);
1609         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1610         RNA_def_property_ui_text(prop, ui_name, ui_description);
1611         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1612
1613         return prop;
1614 }
1615
1616 PropertyRNA *RNA_def_string(StructRNA *srna, const char *identifier, const char *default_value, int maxlen,
1617         const char *ui_name, const char *ui_description)
1618 {
1619         PropertyRNA *prop;
1620         
1621         prop= RNA_def_property(srna, identifier, PROP_STRING, PROP_NONE);
1622         if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
1623         if(default_value) RNA_def_property_string_default(prop, default_value);
1624         RNA_def_property_ui_text(prop, ui_name, ui_description);
1625
1626         return prop;
1627 }
1628
1629 PropertyRNA *RNA_def_string_file_path(StructRNA *srna, const char *identifier, const char *default_value, int maxlen,
1630         const char *ui_name, const char *ui_description)
1631 {
1632         PropertyRNA *prop;
1633         
1634         prop= RNA_def_property(srna, identifier, PROP_STRING, PROP_FILEPATH);
1635         if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
1636         if(default_value) RNA_def_property_string_default(prop, default_value);
1637         RNA_def_property_ui_text(prop, ui_name, ui_description);
1638
1639         return prop;
1640 }
1641
1642 PropertyRNA *RNA_def_string_dir_path(StructRNA *srna, const char *identifier, const char *default_value, int maxlen,
1643         const char *ui_name, const char *ui_description)
1644 {
1645         PropertyRNA *prop;
1646         
1647         prop= RNA_def_property(srna, identifier, PROP_STRING, PROP_DIRPATH);
1648         if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
1649         if(default_value) RNA_def_property_string_default(prop, default_value);
1650         RNA_def_property_ui_text(prop, ui_name, ui_description);
1651
1652         return prop;
1653 }
1654
1655 PropertyRNA *RNA_def_enum(StructRNA *srna, const char *identifier, EnumPropertyItem *items, int default_value,
1656         const char *ui_name, const char *ui_description)
1657 {
1658         PropertyRNA *prop;
1659         
1660         prop= RNA_def_property(srna, identifier, PROP_ENUM, PROP_NONE);
1661         if(items) RNA_def_property_enum_items(prop, items);
1662         RNA_def_property_enum_default(prop, default_value);
1663         RNA_def_property_ui_text(prop, ui_name, ui_description);
1664
1665         return prop;
1666 }
1667
1668 PropertyRNA *RNA_def_float(StructRNA *srna, const char *identifier, float default_value,
1669         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1670 {
1671         PropertyRNA *prop;
1672         
1673         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_NONE);
1674         RNA_def_property_float_default(prop, default_value);
1675         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1676         RNA_def_property_ui_text(prop, ui_name, ui_description);
1677         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1678
1679         return prop;
1680 }
1681
1682 PropertyRNA *RNA_def_float_vector(StructRNA *srna, const char *identifier, int len, const float *default_value,
1683         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1684 {
1685         PropertyRNA *prop;
1686         
1687         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_VECTOR);
1688         if(len != 0) RNA_def_property_array(prop, len);
1689         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1690         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1691         RNA_def_property_ui_text(prop, ui_name, ui_description);
1692         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1693
1694         return prop;
1695 }
1696
1697 PropertyRNA *RNA_def_float_color(StructRNA *srna, const char *identifier, int len, const float *default_value,
1698         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1699 {
1700         PropertyRNA *prop;
1701         
1702         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_COLOR);
1703         if(len != 0) RNA_def_property_array(prop, len);
1704         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1705         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1706         RNA_def_property_ui_text(prop, ui_name, ui_description);
1707         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1708
1709         return prop;
1710 }
1711
1712
1713 PropertyRNA *RNA_def_float_matrix(StructRNA *srna, const char *identifier, int len, const float *default_value,
1714         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1715 {
1716         PropertyRNA *prop;
1717         
1718         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_MATRIX);
1719         if(len != 0) RNA_def_property_array(prop, len);
1720         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1721         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1722         RNA_def_property_ui_text(prop, ui_name, ui_description);
1723         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1724
1725         return prop;
1726 }
1727
1728 PropertyRNA *RNA_def_float_rotation(StructRNA *srna, const char *identifier, int len, const float *default_value,
1729         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1730 {
1731         PropertyRNA *prop;
1732         
1733         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_ROTATION);
1734         if(len != 0) RNA_def_property_array(prop, len);
1735         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1736         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1737         RNA_def_property_ui_text(prop, ui_name, ui_description);
1738         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1739
1740         return prop;
1741 }
1742
1743 PropertyRNA *RNA_def_float_array(StructRNA *srna, const char *identifier, int len, const float *default_value,
1744         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1745 {
1746         PropertyRNA *prop;
1747         
1748         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_NONE);
1749         if(len != 0) RNA_def_property_array(prop, len);
1750         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1751         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1752         RNA_def_property_ui_text(prop, ui_name, ui_description);
1753         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1754
1755         return prop;
1756 }
1757
1758 PropertyRNA *RNA_def_float_percentage(StructRNA *srna, const char *identifier, float default_value,
1759         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1760 {
1761         PropertyRNA *prop;
1762         
1763         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_PERCENTAGE);
1764         RNA_def_property_float_default(prop, default_value);
1765         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1766         RNA_def_property_ui_text(prop, ui_name, ui_description);
1767         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1768
1769         return prop;
1770 }
1771
1772 PropertyRNA *RNA_def_pointer_runtime(StructRNA *srna, const char *identifier, StructRNA *type,
1773         const char *ui_name, const char *ui_description)
1774 {
1775         PropertyRNA *prop;
1776         
1777         prop= RNA_def_property(srna, identifier, PROP_POINTER, PROP_NONE);
1778         RNA_def_property_struct_runtime(prop, type);
1779         RNA_def_property_ui_text(prop, ui_name, ui_description);
1780
1781         return prop;
1782 }
1783
1784 PropertyRNA *RNA_def_collection_runtime(StructRNA *srna, const char *identifier, StructRNA *type,
1785         const char *ui_name, const char *ui_description)
1786 {
1787         PropertyRNA *prop;
1788         
1789         prop= RNA_def_property(srna, identifier, PROP_COLLECTION, PROP_NONE);
1790         RNA_def_property_struct_runtime(prop, type);
1791         RNA_def_property_ui_text(prop, ui_name, ui_description);
1792
1793         return prop;
1794 }
1795