RNA: forgot to rename some values in the keymaps in last commit.
[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 static PropertyDefRNA *rna_find_def_property(StructRNA *srna, PropertyRNA *prop)
320 {
321         StructDefRNA *ds= rna_find_def_struct(srna);
322         PropertyDefRNA *dp;
323
324         if(ds)
325                 for(dp=ds->properties.first; dp; dp=dp->next)
326                         if(dp->prop == prop)
327                                 return dp;
328         
329         return NULL;
330 }
331
332 /* Struct Definition */
333
334 StructRNA *RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *from)
335 {
336         StructRNA *srna, *srnafrom= NULL;
337         StructDefRNA *ds= NULL, *dsfrom= NULL;
338         PropertyRNA *prop, *propfrom;
339         
340         if(DefRNA.preprocess) {
341                 char error[512];
342
343                 if (rna_validate_identifier(identifier, error, 0) == 0) {
344                         fprintf(stderr, "RNA_def_struct: struct identifier \"%s\" error - %s\n", identifier, error);
345                         DefRNA.error= 1;
346                 }
347         }
348         
349         if(from) {
350                 /* find struct to derive from */
351                 for(srnafrom= brna->structs.first; srnafrom; srnafrom=srnafrom->next)
352                         if(strcmp(srnafrom->identifier, from) == 0)
353                                 break;
354
355                 if(!srnafrom) {
356                         fprintf(stderr, "RNA_def_struct: struct %s not found to define %s.\n", from, identifier);
357                         DefRNA.error= 1;
358                 }
359         }
360
361         srna= MEM_callocN(sizeof(StructRNA), "StructRNA");
362         DefRNA.laststruct= srna;
363
364         if(srnafrom) {
365                 /* copy from struct to derive stuff, a bit clumsy since we can't
366                  * use MEM_dupallocN, data structs may not be alloced but builtin */
367                 memcpy(srna, srnafrom, sizeof(StructRNA));
368                 srna->properties.first= srna->properties.last= NULL;
369
370                 if(DefRNA.preprocess) {
371                         srna->base= srnafrom;
372                         dsfrom= rna_find_def_struct(srnafrom);
373                 }
374                 else
375                         srna->base= srnafrom;
376         }
377
378         srna->identifier= identifier;
379         srna->name= identifier; /* may be overwritten later RNA_def_struct_ui_text */
380         srna->description= "";
381
382         rna_addtail(&brna->structs, srna);
383
384         if(DefRNA.preprocess) {
385                 ds= MEM_callocN(sizeof(StructDefRNA), "StructDefRNA");
386                 ds->srna= srna;
387                 rna_addtail(&DefRNA.structs, ds);
388
389                 if(dsfrom)
390                         ds->dnafromname= dsfrom->dnaname;
391         }
392
393         /* in preprocess, try to find sdna */
394         if(DefRNA.preprocess)
395                 RNA_def_struct_sdna(srna, srna->identifier);
396         else
397                 srna->flag |= STRUCT_RUNTIME;
398
399         if(srnafrom) {
400                 /* copy from struct to derive stuff, a bit clumsy since we can't
401                  * use MEM_dupallocN, data structs may not be alloced but builtin */
402
403                 for(propfrom= srnafrom->properties.first; propfrom; propfrom=propfrom->next) {
404                         prop= RNA_def_property(srna, propfrom->identifier, propfrom->type, propfrom->subtype);
405
406                         rna_remlink(&srna->properties, prop);
407                         memcpy(prop, propfrom, rna_property_type_sizeof(propfrom->type));
408
409                         if(!DefRNA.preprocess)
410                                 prop->flag |= PROP_RUNTIME;
411
412                         prop->next= prop->prev= NULL;
413                         rna_addtail(&srna->properties, prop);
414
415                         if(propfrom == srnafrom->nameproperty)
416                                 srna->nameproperty= prop;
417                         if(propfrom == srnafrom->iteratorproperty)
418                                 srna->iteratorproperty= prop;
419
420                         if(DefRNA.preprocess) {
421                                 PropertyDefRNA *dp, *dpfrom;
422                                 
423                                 dp= ds->properties.last;
424                                 dpfrom= rna_find_def_property(srnafrom, propfrom);
425
426                                 rna_remlink(&ds->properties, dp);
427                                 memcpy(dp, dpfrom, sizeof(*dp));
428                                 dp->srna= srna;
429                                 dp->prop= prop;
430                                 dp->next= dp->prev= NULL;
431                                 rna_addtail(&ds->properties, dp);
432                         }
433                 }
434         }
435         else {
436                 /* define some builtin properties */
437                 prop= RNA_def_property(srna, "rna_properties", PROP_COLLECTION, PROP_NONE);
438                 RNA_def_property_flag(prop, PROP_BUILTIN);
439                 RNA_def_property_ui_text(prop, "Properties", "RNA property collection.");
440
441                 if(DefRNA.preprocess) {
442                         RNA_def_property_struct_type(prop, "Property");
443                         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, 0);
444                 }
445                 else {
446 #ifdef RNA_RUNTIME
447                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
448                         cprop->begin= rna_builtin_properties_begin;
449                         cprop->next= rna_builtin_properties_next;
450                         cprop->next= rna_iterator_listbase_end;
451                         cprop->get= rna_builtin_properties_get;
452                         cprop->structtype= &RNA_Property;
453 #endif
454                 }
455
456                 prop= RNA_def_property(srna, "rna_type", PROP_POINTER, PROP_NONE);
457                 RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
458                 RNA_def_property_ui_text(prop, "RNA", "RNA type definition.");
459
460                 if(DefRNA.preprocess) {
461                         RNA_def_property_struct_type(prop, "Struct");
462                         RNA_def_property_pointer_funcs(prop, "rna_builtin_type_get", NULL, NULL);
463                 }
464                 else {
465 #ifdef RNA_RUNTIME
466                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
467                         pprop->get= rna_builtin_type_get;
468                         pprop->structtype= &RNA_Struct;
469 #endif
470                 }
471         }
472
473         return srna;
474 }
475
476 void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
477 {
478         StructDefRNA *ds= DefRNA.structs.last;
479
480         if(!DefRNA.preprocess) {
481                 fprintf(stderr, "RNA_def_struct_sdna: only during preprocessing.\n");
482                 return;
483         }
484
485         if(!DNA_struct_find_nr(DefRNA.sdna, structname)) {
486                 if(!DefRNA.silent) {
487                         fprintf(stderr, "RNA_def_struct_sdna: %s not found.\n", structname);
488                         DefRNA.error= 1;
489                 }
490                 return;
491         }
492
493         ds->dnaname= structname;
494 }
495
496 void RNA_def_struct_sdna_from(StructRNA *srna, const char *structname, const char *propname)
497 {
498         StructDefRNA *ds= DefRNA.structs.last;
499
500         if(!DefRNA.preprocess) {
501                 fprintf(stderr, "RNA_def_struct_sdna_from: only during preprocessing.\n");
502                 return;
503         }
504
505         if(!ds->dnaname) {
506                 fprintf(stderr, "RNA_def_struct_sdna_from: %s base struct must know DNA already.\n", structname);
507                 return;
508         }
509
510         if(!DNA_struct_find_nr(DefRNA.sdna, structname)) {
511                 if(!DefRNA.silent) {
512                         fprintf(stderr, "RNA_def_struct_sdna_from: %s not found.\n", structname);
513                         DefRNA.error= 1;
514                 }
515                 return;
516         }
517
518         ds->dnafromprop= propname;
519         ds->dnaname= structname;
520 }
521
522 void RNA_def_struct_name_property(struct StructRNA *srna, struct PropertyRNA *prop)
523 {
524         if(prop->type != PROP_STRING) {
525                 fprintf(stderr, "RNA_def_struct_name_property: %s.%s, must be a string property.\n", srna->identifier, prop->identifier);
526                 DefRNA.error= 1;
527         }
528         else
529                 srna->nameproperty= prop;
530 }
531
532 void RNA_def_struct_nested(BlenderRNA *brna, StructRNA *srna, const char *structname)
533 {
534         StructRNA *srnafrom;
535
536         /* find struct to derive from */
537         for(srnafrom= brna->structs.first; srnafrom; srnafrom=srnafrom->next)
538                 if(strcmp(srnafrom->identifier, structname) == 0)
539                         break;
540
541         if(!srnafrom) {
542                 fprintf(stderr, "RNA_def_struct_nested: struct %s not found.\n", structname);
543                 DefRNA.error= 1;
544         }
545
546         srna->nested= srnafrom;
547 }
548
549 void RNA_def_struct_flag(StructRNA *srna, int flag)
550 {
551         srna->flag= flag;
552 }
553
554 void RNA_def_struct_refine_func(StructRNA *srna, const char *refine)
555 {
556         if(!DefRNA.preprocess) {
557                 fprintf(stderr, "RNA_def_struct_refine_func: only during preprocessing.\n");
558                 return;
559         }
560
561         if(refine) srna->refine= (StructRefineFunc)refine;
562 }
563
564 void RNA_def_struct_identifier(StructRNA *srna, const char *identifier)
565 {
566         if(DefRNA.preprocess) {
567                 fprintf(stderr, "RNA_def_struct_name_runtime: only at runtime.\n");
568                 return;
569         }
570
571         srna->identifier= identifier;
572 }
573
574 void RNA_def_struct_ui_text(StructRNA *srna, const char *name, const char *description)
575 {
576         srna->name= name;
577         srna->description= description;
578 }
579
580 void RNA_struct_free(BlenderRNA *brna, StructRNA *srna)
581 {
582         rna_freelistN(&srna->properties);
583         rna_freelinkN(&brna->structs, srna);
584 }
585
586 /* Property Definition */
587
588 PropertyRNA *RNA_def_property(StructRNA *srna, const char *identifier, int type, int subtype)
589 {
590         StructDefRNA *ds;
591         PropertyDefRNA *dp= NULL;
592         PropertyRNA *prop;
593
594         if(DefRNA.preprocess) {
595                 char error[512];
596                 
597                 if (rna_validate_identifier(identifier, error, 1) == 0) {
598                         fprintf(stderr, "RNA_def_property: property identifier \"%s\" - %s\n", identifier, error);
599                         DefRNA.error= 1;
600                 }
601                 
602                 ds= DefRNA.structs.last;
603                 dp= MEM_callocN(sizeof(PropertyDefRNA), "PropertyDefRNA");
604                 rna_addtail(&ds->properties, dp);
605         }
606
607         prop= MEM_callocN(rna_property_type_sizeof(type), "PropertyRNA");
608
609         switch(type) {
610                 case PROP_BOOLEAN:
611                         break;
612                 case PROP_INT: {
613                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
614
615                         iprop->hardmin= (subtype == PROP_UNSIGNED)? 0: INT_MIN;
616                         iprop->hardmax= INT_MAX;
617
618                         iprop->softmin= (subtype == PROP_UNSIGNED)? 0: -10000; /* rather arbitrary .. */
619                         iprop->softmax= 10000;
620                         iprop->step= 1;
621                         break;
622                 }
623                 case PROP_FLOAT: {
624                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
625
626                         fprop->hardmin= (subtype == PROP_UNSIGNED)? 0.0f: -FLT_MAX;
627                         fprop->hardmax= FLT_MAX;
628
629                         if(subtype == PROP_COLOR) {
630                                 fprop->softmin= 0.0f;
631                                 fprop->softmax= 1.0f;
632                         }
633                         else {
634                                 fprop->softmin= (subtype == PROP_UNSIGNED)? 0.0f: -10000.0f; /* rather arbitrary .. */
635                                 fprop->softmax= 10000.0f;
636                         }
637                         fprop->step= 10;
638                         fprop->precision= 3;
639                         break;
640                 }
641                 case PROP_STRING: {
642                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
643
644                         sprop->defaultvalue= "";
645                         sprop->maxlength= 0;
646                         break;
647                 }
648                 case PROP_ENUM:
649                 case PROP_POINTER:
650                 case PROP_COLLECTION:
651                         break;
652                 default:
653                         fprintf(stderr, "RNA_def_property: %s.%s, invalid property type.\n", srna->identifier, identifier);
654                         DefRNA.error= 1;
655                         return NULL;
656         }
657
658         if(DefRNA.preprocess) {
659                 dp->srna= srna;
660                 dp->prop= prop;
661         }
662
663         prop->magic= RNA_MAGIC;
664         prop->identifier= identifier;
665         prop->type= type;
666         prop->subtype= subtype;
667         prop->name= identifier;
668         prop->description= "";
669
670         if(type == PROP_COLLECTION || type == PROP_POINTER)
671                 prop->flag= PROP_NOT_EDITABLE|PROP_NOT_DRIVEABLE;
672
673         if(DefRNA.preprocess) {
674                 switch(type) {
675                         case PROP_BOOLEAN:
676                                 DefRNA.silent= 1;
677                                 RNA_def_property_boolean_sdna(prop, NULL, identifier, 0);
678                                 DefRNA.silent= 0;
679                                 break;
680                         case PROP_INT: {
681                                 DefRNA.silent= 1;
682                                 RNA_def_property_int_sdna(prop, NULL, identifier);
683                                 DefRNA.silent= 0;
684                                 break;
685                         }
686                         case PROP_FLOAT: {
687                                 DefRNA.silent= 1;
688                                 RNA_def_property_float_sdna(prop, NULL, identifier);
689                                 DefRNA.silent= 0;
690                                 break;
691                         }
692                         case PROP_STRING: {
693                                 DefRNA.silent= 1;
694                                 RNA_def_property_string_sdna(prop, NULL, identifier);
695                                 DefRNA.silent= 0;
696                                 break;
697                         }
698                         case PROP_ENUM:
699                                 DefRNA.silent= 1;
700                                 RNA_def_property_enum_sdna(prop, NULL, identifier);
701                                 DefRNA.silent= 0;
702                                 break;
703                         case PROP_POINTER:
704                                 DefRNA.silent= 1;
705                                 RNA_def_property_pointer_sdna(prop, NULL, identifier);
706                                 DefRNA.silent= 0;
707                                 break;
708                         case PROP_COLLECTION:
709                                 DefRNA.silent= 1;
710                                 RNA_def_property_collection_sdna(prop, NULL, identifier, NULL);
711                                 DefRNA.silent= 0;
712                                 break;
713                 }
714         }
715         else
716                 prop->flag |= PROP_IDPROPERTY|PROP_RUNTIME;
717
718         rna_addtail(&srna->properties, prop);
719
720         return prop;
721 }
722
723 void RNA_def_property_flag(PropertyRNA *prop, int flag)
724 {
725 #if 0
726         StructRNA *srna;
727 #endif
728
729         prop->flag |= flag;
730
731 #if 0
732         if(prop->type != PROP_POINTER && prop->type != PROP_COLLECTION) {
733                 if(flag & (PROP_EVALUATE_DEPENDENCY|PROP_INVERSE_EVALUATE_DEPENDENCY|PROP_RENDER_DEPENDENCY|PROP_INVERSE_RENDER_DEPENDENCY)) {
734                         fprintf(stderr, "RNA_def_property_flag: %s.%s, only pointer and collection types can create dependencies.\n", ds->srna->identifier, prop->identifier);
735                         DefRNA.error= 1;
736                 }
737         }
738 #endif
739 }
740
741 void RNA_def_property_array(PropertyRNA *prop, int arraylength)
742 {
743         StructRNA *srna= DefRNA.laststruct;
744
745         switch(prop->type) {
746                 case PROP_BOOLEAN:
747                 case PROP_INT:
748                 case PROP_FLOAT:
749                         prop->arraylength= arraylength;
750                         break;
751                 default:
752                         fprintf(stderr, "RNA_def_property_array: %s.%s, only boolean/int/float can be array.\n", srna->identifier, prop->identifier);
753                         DefRNA.error= 1;
754                         break;
755         }
756 }
757
758 void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description)
759 {
760         prop->name= name;
761         prop->description= description;
762 }
763
764 void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
765 {
766         StructRNA *srna= DefRNA.laststruct;
767
768         switch(prop->type) {
769                 case PROP_INT: {
770                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
771                         iprop->softmin= (int)min;
772                         iprop->softmax= (int)max;
773                         iprop->step= (int)step;
774                         break;
775                 }
776                 case PROP_FLOAT: {
777                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
778                         fprop->softmin= (float)min;
779                         fprop->softmax= (float)max;
780                         fprop->step= (float)step;
781                         fprop->precision= (int)precision;
782                         break;
783                 }
784                 default:
785                         fprintf(stderr, "RNA_def_property_ui_range: %s.%s, invalid type for ui range.\n", srna->identifier, prop->identifier);
786                         DefRNA.error= 1;
787                         break;
788         }
789 }
790
791 void RNA_def_property_range(PropertyRNA *prop, double min, double max)
792 {
793         StructRNA *srna= DefRNA.laststruct;
794
795         switch(prop->type) {
796                 case PROP_INT: {
797                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
798                         iprop->hardmin= (int)min;
799                         iprop->hardmax= (int)max;
800                         iprop->softmin= MAX2((int)min, iprop->hardmin);
801                         iprop->softmax= MIN2((int)max, iprop->hardmax);
802                         break;
803                 }
804                 case PROP_FLOAT: {
805                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
806                         fprop->hardmin= (float)min;
807                         fprop->hardmax= (float)max;
808                         fprop->softmin= MAX2((float)min, fprop->hardmin);
809                         fprop->softmax= MIN2((float)max, fprop->hardmax);
810                         break;
811                 }
812                 default:
813                         fprintf(stderr, "RNA_def_property_range: %s.%s, invalid type for range.\n", srna->identifier, prop->identifier);
814                         DefRNA.error= 1;
815                         break;
816         }
817 }
818
819 void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
820 {
821         StructRNA *srna= DefRNA.laststruct;
822
823         if(!DefRNA.preprocess) {
824                 fprintf(stderr, "RNA_def_property_struct_type: only during preprocessing.\n");
825                 return;
826         }
827
828         switch(prop->type) {
829                 case PROP_POINTER: {
830                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
831                         pprop->structtype = (StructRNA*)type;
832                         break;
833                 }
834                 case PROP_COLLECTION: {
835                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
836                         cprop->structtype = (StructRNA*)type;
837                         break;
838                 }
839                 default:
840                         fprintf(stderr, "RNA_def_property_struct_type: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
841                         DefRNA.error= 1;
842                         break;
843         }
844 }
845
846 void RNA_def_property_struct_runtime(PropertyRNA *prop, StructRNA *type)
847 {
848         StructRNA *srna= DefRNA.laststruct;
849
850         if(DefRNA.preprocess) {
851                 fprintf(stderr, "RNA_def_property_struct_runtime: only at runtime.\n");
852                 return;
853         }
854
855         switch(prop->type) {
856                 case PROP_POINTER: {
857                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
858                         pprop->structtype = type;
859                         break;
860                 }
861                 case PROP_COLLECTION: {
862                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
863                         cprop->structtype = type;
864                         break;
865                 }
866                 default:
867                         fprintf(stderr, "RNA_def_property_struct_runtime: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
868                         DefRNA.error= 1;
869                         break;
870         }
871 }
872
873 void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item)
874 {
875         StructRNA *srna= DefRNA.laststruct;
876         int i;
877
878         switch(prop->type) {
879                 case PROP_ENUM: {
880                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
881                         eprop->item= item;
882                         eprop->totitem= 0;
883                         for(i=0; item[i].identifier; i++)
884                                 eprop->totitem++;
885
886                         break;
887                 }
888                 default:
889                         fprintf(stderr, "RNA_def_property_enum_items: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
890                         DefRNA.error= 1;
891                         break;
892         }
893 }
894
895 void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
896 {
897         StructRNA *srna= DefRNA.laststruct;
898
899         switch(prop->type) {
900                 case PROP_STRING: {
901                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
902                         sprop->maxlength= maxlength;
903                         break;
904                 }
905                 default:
906                         fprintf(stderr, "RNA_def_property_string_maxlength: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
907                         DefRNA.error= 1;
908                         break;
909         }
910 }
911
912 void RNA_def_property_boolean_default(PropertyRNA *prop, int value)
913 {
914         StructRNA *srna= DefRNA.laststruct;
915
916         switch(prop->type) {
917                 case PROP_BOOLEAN: {
918                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
919                         bprop->defaultvalue= value;
920                         break;
921                 }
922                 default:
923                         fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
924                         DefRNA.error= 1;
925                         break;
926         }
927 }
928
929 void RNA_def_property_boolean_array_default(PropertyRNA *prop, const int *array)
930 {
931         StructRNA *srna= DefRNA.laststruct;
932
933         switch(prop->type) {
934                 case PROP_BOOLEAN: {
935                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
936                         bprop->defaultarray= array;
937                         break;
938                 }
939                 default:
940                         fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
941                         DefRNA.error= 1;
942                         break;
943         }
944 }
945
946 void RNA_def_property_int_default(PropertyRNA *prop, int value)
947 {
948         StructRNA *srna= DefRNA.laststruct;
949
950         switch(prop->type) {
951                 case PROP_INT: {
952                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
953                         iprop->defaultvalue= value;
954                         break;
955                 }
956                 default:
957                         fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
958                         DefRNA.error= 1;
959                         break;
960         }
961 }
962
963 void RNA_def_property_int_array_default(PropertyRNA *prop, const int *array)
964 {
965         StructRNA *srna= DefRNA.laststruct;
966
967         switch(prop->type) {
968                 case PROP_INT: {
969                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
970                         iprop->defaultarray= array;
971                         break;
972                 }
973                 default:
974                         fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
975                         DefRNA.error= 1;
976                         break;
977         }
978 }
979
980 void RNA_def_property_float_default(PropertyRNA *prop, float value)
981 {
982         StructRNA *srna= DefRNA.laststruct;
983
984         switch(prop->type) {
985                 case PROP_FLOAT: {
986                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
987                         fprop->defaultvalue= value;
988                         break;
989                 }
990                 default:
991                         fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
992                         DefRNA.error= 1;
993                         break;
994         }
995 }
996
997 void RNA_def_property_float_array_default(PropertyRNA *prop, const float *array)
998 {
999         StructRNA *srna= DefRNA.laststruct;
1000
1001         switch(prop->type) {
1002                 case PROP_FLOAT: {
1003                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
1004                         fprop->defaultarray= array;
1005                         break;
1006                 }
1007                 default:
1008                         fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
1009                         DefRNA.error= 1;
1010                         break;
1011         }
1012 }
1013
1014 void RNA_def_property_string_default(PropertyRNA *prop, const char *value)
1015 {
1016         StructRNA *srna= DefRNA.laststruct;
1017
1018         switch(prop->type) {
1019                 case PROP_STRING: {
1020                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
1021                         sprop->defaultvalue= value;
1022                         break;
1023                 }
1024                 default:
1025                         fprintf(stderr, "RNA_def_property_string_default: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
1026                         DefRNA.error= 1;
1027                         break;
1028         }
1029 }
1030
1031 void RNA_def_property_enum_default(PropertyRNA *prop, int value)
1032 {
1033         StructRNA *srna= DefRNA.laststruct;
1034
1035         switch(prop->type) {
1036                 case PROP_ENUM: {
1037                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
1038                         eprop->defaultvalue= value;
1039                         break;
1040                 }
1041                 default:
1042                         fprintf(stderr, "RNA_def_property_enum_default: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
1043                         DefRNA.error= 1;
1044                         break;
1045         }
1046 }
1047
1048 /* SDNA */
1049
1050 static PropertyDefRNA *rna_def_property_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1051 {
1052         DNAStructMember smember;
1053         StructDefRNA *ds= DefRNA.structs.last;
1054         PropertyDefRNA *dp= ds->properties.last;
1055
1056         if(!structname)
1057                 structname= ds->dnaname;
1058         if(!propname)
1059                 propname= prop->identifier;
1060
1061         if(!rna_find_sdna_member(DefRNA.sdna, structname, propname, &smember)) {
1062                 if(!DefRNA.silent) {
1063                         fprintf(stderr, "rna_def_property_sdna: %s.%s not found.\n", structname, propname);
1064                         DefRNA.error= 1;
1065                 }
1066                 return NULL;
1067         }
1068
1069         if(smember.arraylength > 1)
1070                 prop->arraylength= smember.arraylength;
1071         else
1072                 prop->arraylength= 0;
1073         
1074         dp->dnastructname= structname;
1075         dp->dnastructfromname= ds->dnafromname;
1076         dp->dnastructfromprop= ds->dnafromprop;
1077         dp->dnaname= propname;
1078         dp->dnatype= smember.type;
1079         dp->dnaarraylength= smember.arraylength;
1080         dp->dnapointerlevel= smember.pointerlevel;
1081
1082         return dp;
1083 }
1084
1085 void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int bit)
1086 {
1087         PropertyDefRNA *dp;
1088         StructRNA *srna= DefRNA.laststruct;
1089         
1090         if(!DefRNA.preprocess) {
1091                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1092                 return;
1093         }
1094
1095         if(prop->type != PROP_BOOLEAN) {
1096                 fprintf(stderr, "RNA_def_property_boolean_sdna: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
1097                 DefRNA.error= 1;
1098                 return;
1099         }
1100
1101         if((dp=rna_def_property_sdna(prop, structname, propname)))
1102                 dp->booleanbit= bit;
1103 }
1104
1105 void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname, const char *propname, int booleanbit)
1106 {
1107         StructDefRNA *ds;
1108         PropertyDefRNA *dp;
1109
1110         RNA_def_property_boolean_sdna(prop, structname, propname, booleanbit);
1111
1112         if((ds=DefRNA.structs.last) && (dp=ds->properties.last))
1113                 dp->booleannegative= 1;
1114 }
1115
1116 void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1117 {
1118         PropertyDefRNA *dp;
1119         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
1120         StructRNA *srna= DefRNA.laststruct;
1121         
1122         if(!DefRNA.preprocess) {
1123                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1124                 return;
1125         }
1126
1127         if(prop->type != PROP_INT) {
1128                 fprintf(stderr, "RNA_def_property_int_sdna: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
1129                 DefRNA.error= 1;
1130                 return;
1131         }
1132
1133         if((dp= rna_def_property_sdna(prop, structname, propname))) {
1134                 /* SDNA doesn't pass us unsigned unfortunately .. */
1135                 if(strcmp(dp->dnatype, "char") == 0) {
1136                         iprop->hardmin= iprop->softmin= CHAR_MIN;
1137                         iprop->hardmax= iprop->softmax= CHAR_MAX;
1138                 }
1139                 else if(strcmp(dp->dnatype, "short") == 0) {
1140                         iprop->hardmin= iprop->softmin= SHRT_MIN;
1141                         iprop->hardmax= iprop->softmax= SHRT_MAX;
1142                 }
1143                 else if(strcmp(dp->dnatype, "int") == 0) {
1144                         iprop->hardmin= INT_MIN;
1145                         iprop->hardmax= INT_MAX;
1146
1147                         iprop->softmin= -10000; /* rather arbitrary .. */
1148                         iprop->softmax= 10000;
1149                 }
1150
1151                 if(prop->subtype == PROP_UNSIGNED)
1152                         iprop->hardmin= iprop->softmin= 0;
1153         }
1154 }
1155
1156 void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1157 {
1158         StructRNA *srna= DefRNA.laststruct;
1159
1160         if(!DefRNA.preprocess) {
1161                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1162                 return;
1163         }
1164
1165         if(prop->type != PROP_FLOAT) {
1166                 fprintf(stderr, "RNA_def_property_float_sdna: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
1167                 DefRNA.error= 1;
1168                 return;
1169         }
1170
1171         rna_def_property_sdna(prop, structname, propname);
1172 }
1173
1174 void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1175 {
1176         PropertyDefRNA *dp;
1177         StructRNA *srna= DefRNA.laststruct;
1178         
1179         if(!DefRNA.preprocess) {
1180                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1181                 return;
1182         }
1183
1184         if(prop->type != PROP_ENUM) {
1185                 fprintf(stderr, "RNA_def_property_enum_sdna: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
1186                 DefRNA.error= 1;
1187                 return;
1188         }
1189
1190         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1191                 if(prop->arraylength) {
1192                         prop->arraylength= 0;
1193                         if(!DefRNA.silent) {
1194                                 fprintf(stderr, "RNA_def_property_enum_sdna: %s.%s, array not supported for enum type.\n", structname, propname);
1195                                 DefRNA.error= 1;
1196                         }
1197                 }
1198         }
1199 }
1200
1201 void RNA_def_property_enum_bitflag_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1202 {
1203         StructDefRNA *ds;
1204         PropertyDefRNA *dp;
1205
1206         RNA_def_property_enum_sdna(prop, structname, propname);
1207
1208         if((ds=DefRNA.structs.last) && (dp=ds->properties.last))
1209                 dp->enumbitflags= 1;
1210 }
1211
1212 void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1213 {
1214         PropertyDefRNA *dp;
1215         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
1216         StructRNA *srna= DefRNA.laststruct;
1217
1218         if(!DefRNA.preprocess) {
1219                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1220                 return;
1221         }
1222
1223         if(prop->type != PROP_STRING) {
1224                 fprintf(stderr, "RNA_def_property_string_sdna: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
1225                 DefRNA.error= 1;
1226                 return;
1227         }
1228
1229         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1230                 if(prop->arraylength) {
1231                         sprop->maxlength= prop->arraylength;
1232                         prop->arraylength= 0;
1233                 }
1234         }
1235 }
1236
1237 void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1238 {
1239         PropertyDefRNA *dp;
1240         StructRNA *srna= DefRNA.laststruct;
1241         
1242         if(!DefRNA.preprocess) {
1243                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1244                 return;
1245         }
1246
1247         if(prop->type != PROP_POINTER) {
1248                 fprintf(stderr, "RNA_def_property_pointer_sdna: %s.%s, type is not pointer.\n", srna->identifier, prop->identifier);
1249                 DefRNA.error= 1;
1250                 return;
1251         }
1252
1253         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1254                 if(prop->arraylength) {
1255                         prop->arraylength= 0;
1256                         if(!DefRNA.silent) {
1257                                 fprintf(stderr, "RNA_def_property_pointer_sdna: %s.%s, array not supported for pointer type.\n", structname, propname);
1258                                 DefRNA.error= 1;
1259                         }
1260                 }
1261         }
1262 }
1263
1264 void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname, const char *lengthpropname)
1265 {
1266         PropertyDefRNA *dp;
1267         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
1268         StructRNA *srna= DefRNA.laststruct;
1269
1270         if(!DefRNA.preprocess) {
1271                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1272                 return;
1273         }
1274
1275         if(prop->type != PROP_COLLECTION) {
1276                 fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s, type is not collection.\n", srna->identifier, prop->identifier);
1277                 DefRNA.error= 1;
1278                 return;
1279         }
1280
1281         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1282                 if(prop->arraylength && !lengthpropname) {
1283                         prop->arraylength= 0;
1284
1285                         if(!DefRNA.silent) {
1286                                 fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s, array of collections not supported.\n", structname, propname);
1287                                 DefRNA.error= 1;
1288                         }
1289                 }
1290
1291                 if(strcmp(dp->dnatype, "ListBase") == 0) {
1292                         cprop->next= (PropCollectionNextFunc)"rna_iterator_listbase_next";
1293                         cprop->get= (PropCollectionGetFunc)"rna_iterator_listbase_get";
1294                         cprop->end= (PropCollectionEndFunc)"rna_iterator_listbase_end";
1295                 }
1296         }
1297
1298         if(dp && lengthpropname) {
1299                 DNAStructMember smember;
1300                 StructDefRNA *ds= DefRNA.structs.last;
1301
1302                 if(!structname)
1303                         structname= ds->dnaname;
1304
1305                 if(lengthpropname[0] == 0 || rna_find_sdna_member(DefRNA.sdna, structname, lengthpropname, &smember)) {
1306                         if(lengthpropname[0] == 0) {
1307                                 dp->dnalengthfixed= prop->arraylength;
1308                                 prop->arraylength= 0;
1309                         }
1310                         else {
1311                                 dp->dnalengthstructname= structname;
1312                                 dp->dnalengthname= lengthpropname;
1313                         }
1314
1315                         cprop->next= (PropCollectionNextFunc)"rna_iterator_array_next";
1316                         cprop->end= (PropCollectionEndFunc)"rna_iterator_array_end";
1317
1318                         if(dp->dnapointerlevel >= 2) 
1319                                 cprop->get= (PropCollectionGetFunc)"rna_iterator_array_dereference_get";
1320                         else
1321                                 cprop->get= (PropCollectionGetFunc)"rna_iterator_array_get";
1322                 }
1323                 else {
1324                         if(!DefRNA.silent) {
1325                                 fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s not found.\n", structname, lengthpropname);
1326                                 DefRNA.error= 1;
1327                         }
1328                 }
1329         }
1330 }
1331
1332 /* Functions */
1333
1334 void RNA_def_property_editable_func(PropertyRNA *prop, const char *editable)
1335 {
1336         if(!DefRNA.preprocess) {
1337                 fprintf(stderr, "RNA_def_property_editable_func: only during preprocessing.\n");
1338                 return;
1339         }
1340
1341         if(editable) prop->editable= (EditableFunc)editable;
1342 }
1343
1344 void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *func)
1345 {
1346         if(!DefRNA.preprocess) {
1347                 fprintf(stderr, "RNA_def_struct_refine_func: only during preprocessing.\n");
1348                 return;
1349         }
1350
1351         prop->noteflag= noteflag;
1352         prop->update= (UpdateFunc)func;
1353 }
1354
1355 void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
1356 {
1357         StructRNA *srna= DefRNA.laststruct;
1358
1359         if(!DefRNA.preprocess) {
1360                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1361                 return;
1362         }
1363
1364         switch(prop->type) {
1365                 case PROP_BOOLEAN: {
1366                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
1367
1368                         if(prop->arraylength) {
1369                                 if(get) bprop->getarray= (PropBooleanArrayGetFunc)get;
1370                                 if(set) bprop->setarray= (PropBooleanArraySetFunc)set;
1371                         }
1372                         else {
1373                                 if(get) bprop->get= (PropBooleanGetFunc)get;
1374                                 if(set) bprop->set= (PropBooleanSetFunc)set;
1375                         }
1376                         break;
1377                 }
1378                 default:
1379                         fprintf(stderr, "RNA_def_property_boolean_funcs: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
1380                         DefRNA.error= 1;
1381                         break;
1382         }
1383 }
1384
1385 void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
1386 {
1387         StructRNA *srna= DefRNA.laststruct;
1388
1389         if(!DefRNA.preprocess) {
1390                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1391                 return;
1392         }
1393
1394         switch(prop->type) {
1395                 case PROP_INT: {
1396                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
1397
1398                         if(prop->arraylength) {
1399                                 if(get) iprop->getarray= (PropIntArrayGetFunc)get;
1400                                 if(set) iprop->setarray= (PropIntArraySetFunc)set;
1401                         }
1402                         else {
1403                                 if(get) iprop->get= (PropIntGetFunc)get;
1404                                 if(set) iprop->set= (PropIntSetFunc)set;
1405                         }
1406                         if(range) iprop->range= (PropIntRangeFunc)range;
1407                         break;
1408                 }
1409                 default:
1410                         fprintf(stderr, "RNA_def_property_int_funcs: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
1411                         DefRNA.error= 1;
1412                         break;
1413         }
1414 }
1415
1416 void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
1417 {
1418         StructRNA *srna= DefRNA.laststruct;
1419
1420         if(!DefRNA.preprocess) {
1421                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1422                 return;
1423         }
1424
1425         switch(prop->type) {
1426                 case PROP_FLOAT: {
1427                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
1428
1429                         if(prop->arraylength) {
1430                                 if(get) fprop->getarray= (PropFloatArrayGetFunc)get;
1431                                 if(set) fprop->setarray= (PropFloatArraySetFunc)set;
1432                         }
1433                         else {
1434                                 if(get) fprop->get= (PropFloatGetFunc)get;
1435                                 if(set) fprop->set= (PropFloatSetFunc)set;
1436                         }
1437                         if(range) fprop->range= (PropFloatRangeFunc)range;
1438                         break;
1439                 }
1440                 default:
1441                         fprintf(stderr, "RNA_def_property_float_funcs: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
1442                         DefRNA.error= 1;
1443                         break;
1444         }
1445 }
1446
1447 void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char *set)
1448 {
1449         StructRNA *srna= DefRNA.laststruct;
1450
1451         if(!DefRNA.preprocess) {
1452                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1453                 return;
1454         }
1455
1456         switch(prop->type) {
1457                 case PROP_ENUM: {
1458                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
1459
1460                         if(get) eprop->get= (PropEnumGetFunc)get;
1461                         if(set) eprop->set= (PropEnumSetFunc)set;
1462                         break;
1463                 }
1464                 default:
1465                         fprintf(stderr, "RNA_def_property_enum_funcs: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
1466                         DefRNA.error= 1;
1467                         break;
1468         }
1469 }
1470
1471 void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
1472 {
1473         StructRNA *srna= DefRNA.laststruct;
1474
1475         if(!DefRNA.preprocess) {
1476                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1477                 return;
1478         }
1479
1480         switch(prop->type) {
1481                 case PROP_STRING: {
1482                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
1483
1484                         if(get) sprop->get= (PropStringGetFunc)get;
1485                         if(length) sprop->length= (PropStringLengthFunc)length;
1486                         if(set) sprop->set= (PropStringSetFunc)set;
1487                         break;
1488                 }
1489                 default:
1490                         fprintf(stderr, "RNA_def_property_string_funcs: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
1491                         DefRNA.error= 1;
1492                         break;
1493         }
1494 }
1495
1496 void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *type, const char *set)
1497 {
1498         StructRNA *srna= DefRNA.laststruct;
1499
1500         if(!DefRNA.preprocess) {
1501                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1502                 return;
1503         }
1504
1505         switch(prop->type) {
1506                 case PROP_POINTER: {
1507                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
1508
1509                         if(get) pprop->get= (PropPointerGetFunc)get;
1510                         if(type) pprop->type= (PropPointerTypeFunc)type;
1511                         if(set) pprop->set= (PropPointerSetFunc)set;
1512                         break;
1513                 }
1514                 default:
1515                         fprintf(stderr, "RNA_def_property_pointer_funcs: %s.%s, type is not pointer.\n", srna->identifier, prop->identifier);
1516                         DefRNA.error= 1;
1517                         break;
1518         }
1519 }
1520
1521 void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, const char *next, const char *end, const char *get, const char *type, const char *length, const char *lookupint, const char *lookupstring)
1522 {
1523         StructRNA *srna= DefRNA.laststruct;
1524
1525         if(!DefRNA.preprocess) {
1526                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1527                 return;
1528         }
1529
1530         switch(prop->type) {
1531                 case PROP_COLLECTION: {
1532                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
1533
1534                         if(begin) cprop->begin= (PropCollectionBeginFunc)begin;
1535                         if(next) cprop->next= (PropCollectionNextFunc)next;
1536                         if(end) cprop->end= (PropCollectionEndFunc)end;
1537                         if(get) cprop->get= (PropCollectionGetFunc)get;
1538                         if(type) cprop->type= (PropCollectionTypeFunc)type;
1539                         if(length) cprop->length= (PropCollectionLengthFunc)length;
1540                         if(lookupint) cprop->lookupint= (PropCollectionLookupIntFunc)lookupint;
1541                         if(lookupstring) cprop->lookupstring= (PropCollectionLookupStringFunc)lookupstring;
1542                         break;
1543                 }
1544                 default:
1545                         fprintf(stderr, "RNA_def_property_collection_funcs: %s.%s, type is not collection.\n", srna->identifier, prop->identifier);
1546                         DefRNA.error= 1;
1547                         break;
1548         }
1549 }
1550
1551 /* Compact definitions */
1552
1553 PropertyRNA *RNA_def_boolean(StructRNA *srna, const char *identifier, int default_value,
1554         const char *ui_name, const char *ui_description)
1555 {
1556         PropertyRNA *prop;
1557         
1558         prop= RNA_def_property(srna, identifier, PROP_BOOLEAN, PROP_NONE);
1559         RNA_def_property_boolean_default(prop, default_value);
1560         RNA_def_property_ui_text(prop, ui_name, ui_description);
1561
1562         return prop;
1563 }
1564
1565 PropertyRNA *RNA_def_int(StructRNA *srna, const char *identifier, int default_value, int hardmin, int hardmax,
1566         const char *ui_name, const char *ui_description, int softmin, int softmax)
1567 {
1568         PropertyRNA *prop;
1569         
1570         prop= RNA_def_property(srna, identifier, PROP_INT, PROP_NONE);
1571         RNA_def_property_int_default(prop, default_value);
1572         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1573         RNA_def_property_ui_text(prop, ui_name, ui_description);
1574         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1575
1576         return prop;
1577 }
1578
1579 PropertyRNA *RNA_def_int_vector(StructRNA *srna, const char *identifier, int len, const int *default_value,
1580         int hardmin, int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
1581 {
1582         PropertyRNA *prop;
1583         
1584         prop= RNA_def_property(srna, identifier, PROP_INT, PROP_VECTOR);
1585         if(len != 0) RNA_def_property_array(prop, len);
1586         if(default_value) RNA_def_property_int_array_default(prop, default_value);
1587         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1588         RNA_def_property_ui_text(prop, ui_name, ui_description);
1589         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1590
1591         return prop;
1592 }
1593
1594 PropertyRNA *RNA_def_int_array(StructRNA *srna, const char *identifier, int len, const int *default_value,
1595         int hardmin, int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
1596 {
1597         PropertyRNA *prop;
1598         
1599         prop= RNA_def_property(srna, identifier, PROP_INT, PROP_NONE);
1600         if(len != 0) RNA_def_property_array(prop, len);
1601         if(default_value) RNA_def_property_int_array_default(prop, default_value);
1602         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1603         RNA_def_property_ui_text(prop, ui_name, ui_description);
1604         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1605
1606         return prop;
1607 }
1608
1609 PropertyRNA *RNA_def_string(StructRNA *srna, const char *identifier, const char *default_value, int maxlen,
1610         const char *ui_name, const char *ui_description)
1611 {
1612         PropertyRNA *prop;
1613         
1614         prop= RNA_def_property(srna, identifier, PROP_STRING, PROP_NONE);
1615         if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
1616         if(default_value) RNA_def_property_string_default(prop, default_value);
1617         RNA_def_property_ui_text(prop, ui_name, ui_description);
1618
1619         return prop;
1620 }
1621
1622 PropertyRNA *RNA_def_string_file_path(StructRNA *srna, const char *identifier, const char *default_value, int maxlen,
1623         const char *ui_name, const char *ui_description)
1624 {
1625         PropertyRNA *prop;
1626         
1627         prop= RNA_def_property(srna, identifier, PROP_STRING, PROP_FILEPATH);
1628         if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
1629         if(default_value) RNA_def_property_string_default(prop, default_value);
1630         RNA_def_property_ui_text(prop, ui_name, ui_description);
1631
1632         return prop;
1633 }
1634
1635 PropertyRNA *RNA_def_string_dir_path(StructRNA *srna, const char *identifier, const char *default_value, int maxlen,
1636         const char *ui_name, const char *ui_description)
1637 {
1638         PropertyRNA *prop;
1639         
1640         prop= RNA_def_property(srna, identifier, PROP_STRING, PROP_DIRPATH);
1641         if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
1642         if(default_value) RNA_def_property_string_default(prop, default_value);
1643         RNA_def_property_ui_text(prop, ui_name, ui_description);
1644
1645         return prop;
1646 }
1647
1648 PropertyRNA *RNA_def_enum(StructRNA *srna, const char *identifier, EnumPropertyItem *items, int default_value,
1649         const char *ui_name, const char *ui_description)
1650 {
1651         PropertyRNA *prop;
1652         
1653         prop= RNA_def_property(srna, identifier, PROP_ENUM, PROP_NONE);
1654         if(items) RNA_def_property_enum_items(prop, items);
1655         RNA_def_property_enum_default(prop, default_value);
1656         RNA_def_property_ui_text(prop, ui_name, ui_description);
1657
1658         return prop;
1659 }
1660
1661 PropertyRNA *RNA_def_float(StructRNA *srna, const char *identifier, float default_value,
1662         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1663 {
1664         PropertyRNA *prop;
1665         
1666         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_NONE);
1667         RNA_def_property_float_default(prop, default_value);
1668         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1669         RNA_def_property_ui_text(prop, ui_name, ui_description);
1670         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1671
1672         return prop;
1673 }
1674
1675 PropertyRNA *RNA_def_float_vector(StructRNA *srna, const char *identifier, int len, const float *default_value,
1676         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1677 {
1678         PropertyRNA *prop;
1679         
1680         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_VECTOR);
1681         if(len != 0) RNA_def_property_array(prop, len);
1682         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1683         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1684         RNA_def_property_ui_text(prop, ui_name, ui_description);
1685         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1686
1687         return prop;
1688 }
1689
1690 PropertyRNA *RNA_def_float_color(StructRNA *srna, const char *identifier, int len, const float *default_value,
1691         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1692 {
1693         PropertyRNA *prop;
1694         
1695         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_COLOR);
1696         if(len != 0) RNA_def_property_array(prop, len);
1697         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1698         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1699         RNA_def_property_ui_text(prop, ui_name, ui_description);
1700         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1701
1702         return prop;
1703 }
1704
1705
1706 PropertyRNA *RNA_def_float_matrix(StructRNA *srna, const char *identifier, int len, const float *default_value,
1707         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1708 {
1709         PropertyRNA *prop;
1710         
1711         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_MATRIX);
1712         if(len != 0) RNA_def_property_array(prop, len);
1713         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1714         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1715         RNA_def_property_ui_text(prop, ui_name, ui_description);
1716         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1717
1718         return prop;
1719 }
1720
1721 PropertyRNA *RNA_def_float_rotation(StructRNA *srna, const char *identifier, int len, const float *default_value,
1722         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1723 {
1724         PropertyRNA *prop;
1725         
1726         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_ROTATION);
1727         if(len != 0) RNA_def_property_array(prop, len);
1728         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1729         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1730         RNA_def_property_ui_text(prop, ui_name, ui_description);
1731         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1732
1733         return prop;
1734 }
1735
1736 PropertyRNA *RNA_def_float_array(StructRNA *srna, const char *identifier, int len, const float *default_value,
1737         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1738 {
1739         PropertyRNA *prop;
1740         
1741         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_NONE);
1742         if(len != 0) RNA_def_property_array(prop, len);
1743         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1744         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1745         RNA_def_property_ui_text(prop, ui_name, ui_description);
1746         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1747
1748         return prop;
1749 }
1750
1751 PropertyRNA *RNA_def_pointer_runtime(StructRNA *srna, const char *identifier, StructRNA *type,
1752         const char *ui_name, const char *ui_description)
1753 {
1754         PropertyRNA *prop;
1755         
1756         prop= RNA_def_property(srna, identifier, PROP_POINTER, PROP_NONE);
1757         RNA_def_property_struct_runtime(prop, type);
1758         RNA_def_property_ui_text(prop, ui_name, ui_description);
1759
1760         return prop;
1761 }
1762
1763 PropertyRNA *RNA_def_collection_runtime(StructRNA *srna, const char *identifier, StructRNA *type,
1764         const char *ui_name, const char *ui_description)
1765 {
1766         PropertyRNA *prop;
1767         
1768         prop= RNA_def_property(srna, identifier, PROP_COLLECTION, PROP_NONE);
1769         RNA_def_property_struct_runtime(prop, type);
1770         RNA_def_property_ui_text(prop, ui_name, ui_description);
1771
1772         return prop;
1773 }
1774