RNA
[blender.git] / source / blender / makesrna / intern / rna_define.c
index 1db6ac6e43ca9b53ba196ea2816dc506b3b41392..8e16c422409225489ba5a187b786c8ed2caacaff 100644 (file)
@@ -157,15 +157,15 @@ BlenderRNA *RNA_create()
 
 void RNA_define_free(BlenderRNA *brna)
 {
-       StructDefRNA *strct;
+       StructDefRNA *srna;
        AllocDefRNA *alloc;
 
        for(alloc=DefRNA.allocs.first; alloc; alloc=alloc->next)
                MEM_freeN(alloc->mem);
        rna_freelistN(&DefRNA.allocs);
 
-       for(strct=DefRNA.structs.first; strct; strct=strct->next)
-               rna_freelistN(&strct->properties);
+       for(srna=DefRNA.structs.first; srna; srna=srna->next)
+               rna_freelistN(&srna->properties);
 
        rna_freelistN(&DefRNA.structs);
 
@@ -179,12 +179,12 @@ void RNA_define_free(BlenderRNA *brna)
 
 void RNA_free(BlenderRNA *brna)
 {
-       StructRNA *strct;
+       StructRNA *srna;
 
        RNA_define_free(brna);
 
-       for(strct=brna->structs.first; strct; strct=strct->next)
-               rna_freelistN(&strct->properties);
+       for(srna=brna->structs.first; srna; srna=srna->next)
+               rna_freelistN(&srna->properties);
 
        rna_freelistN(&brna->structs);
        
@@ -195,23 +195,25 @@ void RNA_free(BlenderRNA *brna)
 
 StructRNA *RNA_def_struct(BlenderRNA *brna, const char *cname, const char *name)
 {
-       StructRNA *strct;
+       StructRNA *srna;
        StructDefRNA *ds;
 
        ds= MEM_callocN(sizeof(StructDefRNA), "StructDefRNA");
        rna_addtail(&DefRNA.structs, ds);
 
-       strct= MEM_callocN(sizeof(StructRNA), "StructRNA");
-       strct->cname= cname;
-       strct->name= name;
+       srna= MEM_callocN(sizeof(StructRNA), "StructRNA");
+       srna->cname= cname;
+       srna->name= name;
 
-       ds->strct= strct;
+       ds->srna= srna;
 
-       rna_addtail(&brna->structs, strct);
+       rna_addtail(&brna->structs, srna);
 
-       RNA_def_struct_sdna(strct, strct->cname);
+       RNA_def_struct_sdna(srna, srna->cname);
 
-       return strct;
+       rna_def_builtin_properties(srna);
+
+       return srna;
 }
 
 void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
@@ -232,16 +234,21 @@ void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
 void RNA_def_struct_name_property(struct StructRNA *srna, struct PropertyRNA *prop)
 {
        if(prop->type != PROP_STRING) {
-               fprintf(stderr, "RNA_def_struct_name_property: must be a string property.\n");
+               fprintf(stderr, "RNA_def_struct_name_property: %s.%s, must be a string property.\n", srna->cname, prop->cname);
                DefRNA.error= 1;
        }
        else
                srna->nameproperty= prop;
 }
 
+void RNA_def_struct_flag(StructRNA *srna, int flag)
+{
+       srna->flag= flag;
+}
+
 /* Property Definition */
 
-PropertyRNA *RNA_def_property(StructRNA *strct, const char *cname, int type, int subtype)
+PropertyRNA *RNA_def_property(StructRNA *srna, const char *cname, int type, int subtype)
 {
        StructDefRNA *ds;
        PropertyDefRNA *dp;
@@ -265,6 +272,7 @@ PropertyRNA *RNA_def_property(StructRNA *strct, const char *cname, int type, int
 
                        iprop->softmin= (subtype == PROP_UNSIGNED)? 0: -10000; /* rather arbitrary .. */
                        iprop->softmax= 10000;
+                       iprop->step= 1;
                        break;
                }
                case PROP_FLOAT: {
@@ -277,6 +285,8 @@ PropertyRNA *RNA_def_property(StructRNA *strct, const char *cname, int type, int
 
                        fprop->softmin= (subtype == PROP_UNSIGNED)? 0.0f: -10000.0f; /* rather arbitrary .. */
                        fprop->softmax= 10000.0f;
+                       fprop->step= 10;
+                       fprop->precision= 3;
                        break;
                }
                case PROP_STRING: {
@@ -298,12 +308,12 @@ PropertyRNA *RNA_def_property(StructRNA *strct, const char *cname, int type, int
                        prop= MEM_callocN(sizeof(CollectionPropertyRNA), "CollectionPropertyRNA");
                        break;
                default:
-                       fprintf(stderr, "RNA_def_property: invalid property type.\n");
+                       fprintf(stderr, "RNA_def_property: %s.%s, invalid property type.\n", ds->srna->cname, cname);
                        DefRNA.error= 1;
                        return NULL;
        }
 
-       dp->strct= strct;
+       dp->srna= srna;
        dp->prop= prop;
 
        prop->cname= cname;
@@ -311,65 +321,80 @@ PropertyRNA *RNA_def_property(StructRNA *strct, const char *cname, int type, int
        prop->subtype= subtype;
        prop->name= cname;
        prop->description= "";
-       prop->flag= PROP_EDITABLE|PROP_EVALUATEABLE;
+
+       if(type == PROP_COLLECTION)
+               prop->flag= PROP_NOT_EDITABLE|PROP_NOT_DRIVEABLE;
+       else if(type == PROP_POINTER)
+               prop->flag= PROP_NOT_DRIVEABLE;
 
        switch(type) {
                case PROP_BOOLEAN:
                        DefRNA.silent= 1;
-                       RNA_def_property_boolean_sdna(prop, strct->cname, cname, 0);
+                       RNA_def_property_boolean_sdna(prop, srna->cname, cname, 0);
                        DefRNA.silent= 0;
                        break;
                case PROP_INT: {
                        DefRNA.silent= 1;
-                       RNA_def_property_int_sdna(prop, strct->cname, cname);
+                       RNA_def_property_int_sdna(prop, srna->cname, cname);
                        DefRNA.silent= 0;
                        break;
                }
                case PROP_FLOAT: {
                        DefRNA.silent= 1;
-                       RNA_def_property_float_sdna(prop, strct->cname, cname);
+                       RNA_def_property_float_sdna(prop, srna->cname, cname);
                        DefRNA.silent= 0;
                        break;
                }
                case PROP_STRING: {
                        DefRNA.silent= 1;
-                       RNA_def_property_string_sdna(prop, strct->cname, cname);
+                       RNA_def_property_string_sdna(prop, srna->cname, cname);
                        DefRNA.silent= 0;
                        break;
                }
                case PROP_ENUM:
                        DefRNA.silent= 1;
-                       RNA_def_property_enum_sdna(prop, strct->cname, cname);
+                       RNA_def_property_enum_sdna(prop, srna->cname, cname);
                        DefRNA.silent= 0;
                        break;
                case PROP_POINTER:
                        DefRNA.silent= 1;
-                       RNA_def_property_pointer_sdna(prop, strct->cname, cname);
+                       RNA_def_property_pointer_sdna(prop, srna->cname, cname);
                        DefRNA.silent= 0;
                        break;
                case PROP_COLLECTION:
                        DefRNA.silent= 1;
-                       RNA_def_property_collection_sdna(prop, strct->cname, cname);
+                       RNA_def_property_collection_sdna(prop, srna->cname, cname, NULL);
                        DefRNA.silent= 0;
                        break;
        }
 
-       rna_addtail(&strct->properties, prop);
+       rna_addtail(&srna->properties, prop);
 
        return prop;
 }
 
-void RNA_def_property_access(PropertyRNA *prop, int editable, int evaluatable)
+void RNA_def_property_flag(PropertyRNA *prop, int flag)
 {
-       if(editable) prop->flag |= PROP_EDITABLE;
-       else prop->flag &= ~PROP_EDITABLE;
+#if 0
+       StructDefRNA *ds= DefRNA.structs.last;
+#endif
+
+       prop->flag |= flag;
 
-       if(evaluatable) prop->flag |= PROP_EVALUATEABLE;
-       else prop->flag &= ~PROP_EVALUATEABLE;
+#if 0
+       if(prop->type != PROP_POINTER && prop->type != PROP_COLLECTION) {
+               if(flag & (PROP_EVALUATE_DEPENDENCY|PROP_INVERSE_EVALUATE_DEPENDENCY|PROP_RENDER_DEPENDENCY|PROP_INVERSE_RENDER_DEPENDENCY)) {
+                       fprintf(stderr, "RNA_def_property_flag: %s.%s, only pointer and collection types can create dependencies.\n", ds->srna->cname, prop->cname);
+                       DefRNA.error= 1;
+               }
+       }
+#endif
 }
 
 void RNA_def_property_array(PropertyRNA *prop, int arraylength)
 {
+       StructDefRNA *ds= DefRNA.structs.last;
+
        switch(prop->type) {
                case PROP_BOOLEAN:
                case PROP_INT:
@@ -377,7 +402,7 @@ void RNA_def_property_array(PropertyRNA *prop, int arraylength)
                        prop->arraylength= arraylength;
                        break;
                default:
-                       fprintf(stderr, "RNA_def_property_array: only boolean/int/float can be array.\n");
+                       fprintf(stderr, "RNA_def_property_array: %s.%s, only boolean/int/float can be array.\n", ds->srna->cname, prop->cname);
                        DefRNA.error= 1;
                        break;
        }
@@ -391,6 +416,8 @@ void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *d
 
 void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, double precision)
 {
+       StructDefRNA *ds= DefRNA.structs.last;
+
        switch(prop->type) {
                case PROP_INT: {
                        IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
@@ -408,7 +435,7 @@ void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_ui_range: invalid type for ui range.\n");
+                       fprintf(stderr, "RNA_def_property_ui_range: %s.%s, invalid type for ui range.\n", ds->srna->cname, prop->cname);
                        DefRNA.error= 1;
                        break;
        }
@@ -416,6 +443,8 @@ void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double
 
 void RNA_def_property_range(PropertyRNA *prop, double min, double max)
 {
+       StructDefRNA *ds= DefRNA.structs.last;
+
        switch(prop->type) {
                case PROP_INT: {
                        IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
@@ -434,7 +463,7 @@ void RNA_def_property_range(PropertyRNA *prop, double min, double max)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_range: invalid type for range.\n");
+                       fprintf(stderr, "RNA_def_property_range: %s.%s, invalid type for range.\n", ds->srna->cname, prop->cname);
                        DefRNA.error= 1;
                        break;
        }
@@ -442,6 +471,8 @@ void RNA_def_property_range(PropertyRNA *prop, double min, double max)
 
 void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
 {
+       StructDefRNA *ds= DefRNA.structs.last;
+
        switch(prop->type) {
                case PROP_POINTER: {
                        PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
@@ -454,7 +485,7 @@ void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_struct_type: invalid type for struct type.\n");
+                       fprintf(stderr, "RNA_def_property_struct_type: %s.%s, invalid type for struct type.\n", ds->srna->cname, prop->cname);
                        DefRNA.error= 1;
                        break;
        }
@@ -462,6 +493,7 @@ void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
 
 void RNA_def_property_enum_items(PropertyRNA *prop, const PropertyEnumItem *item)
 {
+       StructDefRNA *ds= DefRNA.structs.last;
        int i;
 
        switch(prop->type) {
@@ -475,7 +507,7 @@ void RNA_def_property_enum_items(PropertyRNA *prop, const PropertyEnumItem *item
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_struct_type: invalid type for struct type.\n");
+                       fprintf(stderr, "RNA_def_property_struct_type: %s.%s, invalid type for struct type.\n", ds->srna->cname, prop->cname);
                        DefRNA.error= 1;
                        break;
        }
@@ -483,6 +515,8 @@ void RNA_def_property_enum_items(PropertyRNA *prop, const PropertyEnumItem *item
 
 void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
 {
+       StructDefRNA *ds= DefRNA.structs.last;
+
        switch(prop->type) {
                case PROP_STRING: {
                        StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
@@ -490,7 +524,7 @@ void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_string_maxlength: type is not string.\n");
+                       fprintf(stderr, "RNA_def_property_string_maxlength: %s.%s, type is not string.\n", ds->srna->cname, prop->cname);
                        DefRNA.error= 1;
                        break;
        }
@@ -498,6 +532,8 @@ void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
 
 void RNA_def_property_boolean_default(PropertyRNA *prop, int value)
 {
+       StructDefRNA *ds= DefRNA.structs.last;
+
        switch(prop->type) {
                case PROP_BOOLEAN: {
                        BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
@@ -505,7 +541,7 @@ void RNA_def_property_boolean_default(PropertyRNA *prop, int value)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_boolean_default: type is not boolean.\n");
+                       fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", ds->srna->cname, prop->cname);
                        DefRNA.error= 1;
                        break;
        }
@@ -513,6 +549,8 @@ void RNA_def_property_boolean_default(PropertyRNA *prop, int value)
 
 void RNA_def_property_boolean_array_default(PropertyRNA *prop, const int *array)
 {
+       StructDefRNA *ds= DefRNA.structs.last;
+
        switch(prop->type) {
                case PROP_BOOLEAN: {
                        BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
@@ -520,7 +558,7 @@ void RNA_def_property_boolean_array_default(PropertyRNA *prop, const int *array)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_boolean_default: type is not boolean.\n");
+                       fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", ds->srna->cname, prop->cname);
                        DefRNA.error= 1;
                        break;
        }
@@ -528,6 +566,8 @@ void RNA_def_property_boolean_array_default(PropertyRNA *prop, const int *array)
 
 void RNA_def_property_int_default(PropertyRNA *prop, int value)
 {
+       StructDefRNA *ds= DefRNA.structs.last;
+
        switch(prop->type) {
                case PROP_INT: {
                        IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
@@ -535,7 +575,7 @@ void RNA_def_property_int_default(PropertyRNA *prop, int value)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_int_default: type is not int.\n");
+                       fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", ds->srna->cname, prop->cname);
                        DefRNA.error= 1;
                        break;
        }
@@ -543,6 +583,8 @@ void RNA_def_property_int_default(PropertyRNA *prop, int value)
 
 void RNA_def_property_int_array_default(PropertyRNA *prop, const int *array)
 {
+       StructDefRNA *ds= DefRNA.structs.last;
+
        switch(prop->type) {
                case PROP_INT: {
                        IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
@@ -550,7 +592,7 @@ void RNA_def_property_int_array_default(PropertyRNA *prop, const int *array)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_int_default: type is not int.\n");
+                       fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", ds->srna->cname, prop->cname);
                        DefRNA.error= 1;
                        break;
        }
@@ -558,6 +600,8 @@ void RNA_def_property_int_array_default(PropertyRNA *prop, const int *array)
 
 void RNA_def_property_float_default(PropertyRNA *prop, float value)
 {
+       StructDefRNA *ds= DefRNA.structs.last;
+
        switch(prop->type) {
                case PROP_FLOAT: {
                        FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
@@ -565,7 +609,7 @@ void RNA_def_property_float_default(PropertyRNA *prop, float value)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_float_default: type is not float.\n");
+                       fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", ds->srna->cname, prop->cname);
                        DefRNA.error= 1;
                        break;
        }
@@ -573,6 +617,8 @@ void RNA_def_property_float_default(PropertyRNA *prop, float value)
 
 void RNA_def_property_float_array_default(PropertyRNA *prop, const float *array)
 {
+       StructDefRNA *ds= DefRNA.structs.last;
+
        switch(prop->type) {
                case PROP_FLOAT: {
                        FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
@@ -580,7 +626,7 @@ void RNA_def_property_float_array_default(PropertyRNA *prop, const float *array)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_float_default: type is not float.\n");
+                       fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", ds->srna->cname, prop->cname);
                        DefRNA.error= 1;
                        break;
        }
@@ -588,6 +634,8 @@ void RNA_def_property_float_array_default(PropertyRNA *prop, const float *array)
 
 void RNA_def_property_string_default(PropertyRNA *prop, const char *value)
 {
+       StructDefRNA *ds= DefRNA.structs.last;
+
        switch(prop->type) {
                case PROP_STRING: {
                        StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
@@ -595,7 +643,7 @@ void RNA_def_property_string_default(PropertyRNA *prop, const char *value)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_string_default: type is not string.\n");
+                       fprintf(stderr, "RNA_def_property_string_default: %s.%s, type is not string.\n", ds->srna->cname, prop->cname);
                        DefRNA.error= 1;
                        break;
        }
@@ -603,6 +651,8 @@ void RNA_def_property_string_default(PropertyRNA *prop, const char *value)
 
 void RNA_def_property_enum_default(PropertyRNA *prop, int value)
 {
+       StructDefRNA *ds= DefRNA.structs.last;
+
        switch(prop->type) {
                case PROP_ENUM: {
                        EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
@@ -610,7 +660,7 @@ void RNA_def_property_enum_default(PropertyRNA *prop, int value)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_enum_default: type is not enum.\n");
+                       fprintf(stderr, "RNA_def_property_enum_default: %s.%s, type is not enum.\n", ds->srna->cname, prop->cname);
                        DefRNA.error= 1;
                        break;
        }
@@ -734,7 +784,7 @@ void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, co
        }
 }
 
-void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname)
+void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname, const char *lengthpropname)
 {
        PropertyDefRNA *dp;
        CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
@@ -754,94 +804,194 @@ void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname,
                        cprop->get= (PropCollectionGetFunc)"rna_iterator_listbase_get";
                }
        }
+
+       if(dp && lengthpropname) {
+               DNAStructMember smember;
+               StructDefRNA *ds= DefRNA.structs.last;
+
+               if(!structname)
+                       structname= ds->dnaname;
+
+               if(!rna_find_sdna_member(DefRNA.sdna, structname, lengthpropname, &smember)) {
+                       if(!DefRNA.silent) {
+                               fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s not found.\n", structname, lengthpropname);
+                               DefRNA.error= 1;
+                       }
+               }
+               else {
+                       dp->dnalengthstructname= structname;
+                       dp->dnalengthname= lengthpropname;
+
+                       cprop->next= (PropCollectionNextFunc)"rna_iterator_array_next";
+                       cprop->get= (PropCollectionGetFunc)"rna_iterator_array_get";
+                       cprop->end= (PropCollectionEndFunc)"rna_iterator_array_end";
+               }
+       }
 }
 
 /* Functions */
 
-void RNA_def_property_notify_func(PropertyRNA *prop, char *notify)
+void RNA_def_property_notify_func(PropertyRNA *prop, const char *notify)
 {
        if(notify) prop->notify= (PropNotifyFunc)notify;
 }
 
-void RNA_def_property_boolean_funcs(PropertyRNA *prop, char *get, char *set)
+void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
 {
-       BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
+       StructDefRNA *ds= DefRNA.structs.last;
 
-       if(prop->arraylength) {
-               if(get) bprop->getarray= (PropBooleanArrayGetFunc)get;
-               if(set) bprop->setarray= (PropBooleanArraySetFunc)set;
-       }
-       else {
-               if(get) bprop->get= (PropBooleanGetFunc)get;
-               if(set) bprop->set= (PropBooleanSetFunc)set;
+       switch(prop->type) {
+               case PROP_BOOLEAN: {
+                       BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
+
+                       if(prop->arraylength) {
+                               if(get) bprop->getarray= (PropBooleanArrayGetFunc)get;
+                               if(set) bprop->setarray= (PropBooleanArraySetFunc)set;
+                       }
+                       else {
+                               if(get) bprop->get= (PropBooleanGetFunc)get;
+                               if(set) bprop->set= (PropBooleanSetFunc)set;
+                       }
+                       break;
+               }
+               default:
+                       fprintf(stderr, "RNA_def_property_boolean_funcs: %s.%s, type is not boolean.\n", ds->srna->cname, prop->cname);
+                       DefRNA.error= 1;
+                       break;
        }
 }
 
-void RNA_def_property_int_funcs(PropertyRNA *prop, char *get, char *set)
+void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set)
 {
-       IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
+       StructDefRNA *ds= DefRNA.structs.last;
 
-       if(prop->arraylength) {
-               if(get) iprop->getarray= (PropIntArrayGetFunc)get;
-               if(set) iprop->setarray= (PropIntArraySetFunc)set;
-       }
-       else {
-               if(get) iprop->get= (PropIntGetFunc)get;
-               if(set) iprop->set= (PropIntSetFunc)set;
+       switch(prop->type) {
+               case PROP_INT: {
+                       IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
+
+                       if(prop->arraylength) {
+                               if(get) iprop->getarray= (PropIntArrayGetFunc)get;
+                               if(set) iprop->setarray= (PropIntArraySetFunc)set;
+                       }
+                       else {
+                               if(get) iprop->get= (PropIntGetFunc)get;
+                               if(set) iprop->set= (PropIntSetFunc)set;
+                       }
+                       break;
+               }
+               default:
+                       fprintf(stderr, "RNA_def_property_int_funcs: %s.%s, type is not int.\n", ds->srna->cname, prop->cname);
+                       DefRNA.error= 1;
+                       break;
        }
 }
 
-void RNA_def_property_float_funcs(PropertyRNA *prop, char *get, char *set)
+void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set)
 {
-       FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
+       StructDefRNA *ds= DefRNA.structs.last;
 
-       if(prop->arraylength) {
-               if(get) fprop->getarray= (PropFloatArrayGetFunc)get;
-               if(set) fprop->setarray= (PropFloatArraySetFunc)set;
-       }
-       else {
-               if(get) fprop->get= (PropFloatGetFunc)get;
-               if(set) fprop->set= (PropFloatSetFunc)set;
+       switch(prop->type) {
+               case PROP_FLOAT: {
+                       FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
+
+                       if(prop->arraylength) {
+                               if(get) fprop->getarray= (PropFloatArrayGetFunc)get;
+                               if(set) fprop->setarray= (PropFloatArraySetFunc)set;
+                       }
+                       else {
+                               if(get) fprop->get= (PropFloatGetFunc)get;
+                               if(set) fprop->set= (PropFloatSetFunc)set;
+                       }
+                       break;
+               }
+               default:
+                       fprintf(stderr, "RNA_def_property_float_funcs: %s.%s, type is not float.\n", ds->srna->cname, prop->cname);
+                       DefRNA.error= 1;
+                       break;
        }
 }
 
-void RNA_def_property_enum_funcs(PropertyRNA *prop, char *get, char *set)
+void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char *set)
 {
-       EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
+       StructDefRNA *ds= DefRNA.structs.last;
+
+       switch(prop->type) {
+               case PROP_ENUM: {
+                       EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
 
-       if(get) eprop->get= (PropEnumGetFunc)get;
-       if(set) eprop->set= (PropEnumSetFunc)set;
+                       if(get) eprop->get= (PropEnumGetFunc)get;
+                       if(set) eprop->set= (PropEnumSetFunc)set;
+                       break;
+               }
+               default:
+                       fprintf(stderr, "RNA_def_property_enum_funcs: %s.%s, type is not enum.\n", ds->srna->cname, prop->cname);
+                       DefRNA.error= 1;
+                       break;
+       }
 }
 
-void RNA_def_property_string_funcs(PropertyRNA *prop, char *get, char *length, char *set)
+void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
 {
-       StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
+       StructDefRNA *ds= DefRNA.structs.last;
 
-       if(get) sprop->get= (PropStringGetFunc)get;
-       if(length) sprop->length= (PropStringLengthFunc)length;
-       if(set) sprop->set= (PropStringSetFunc)set;
+       switch(prop->type) {
+               case PROP_STRING: {
+                       StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
+
+                       if(get) sprop->get= (PropStringGetFunc)get;
+                       if(length) sprop->length= (PropStringLengthFunc)length;
+                       if(set) sprop->set= (PropStringSetFunc)set;
+                       break;
+               }
+               default:
+                       fprintf(stderr, "RNA_def_property_string_funcs: %s.%s, type is not string.\n", ds->srna->cname, prop->cname);
+                       DefRNA.error= 1;
+                       break;
+       }
 }
 
-void RNA_def_property_pointer_funcs(PropertyRNA *prop, char *get, char *type, char *set)
+void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *type, const char *set)
 {
-       PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
+       StructDefRNA *ds= DefRNA.structs.last;
+
+       switch(prop->type) {
+               case PROP_POINTER: {
+                       PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
 
-       if(get) pprop->get= (PropPointerGetFunc)get;
-       if(type) pprop->type= (PropPointerTypeFunc)type;
-       if(set) pprop->set= (PropPointerSetFunc)set;
+                       if(get) pprop->get= (PropPointerGetFunc)get;
+                       if(type) pprop->type= (PropPointerTypeFunc)type;
+                       if(set) pprop->set= (PropPointerSetFunc)set;
+                       break;
+               }
+               default:
+                       fprintf(stderr, "RNA_def_property_pointer_funcs: %s.%s, type is not pointer.\n", ds->srna->cname, prop->cname);
+                       DefRNA.error= 1;
+                       break;
+       }
 }
 
-void RNA_def_property_collection_funcs(PropertyRNA *prop, char *begin, char *next, char *end, char *get, char *type, char *length, char *lookupint, char *lookupstring)
+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)
 {
-       CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
+       StructDefRNA *ds= DefRNA.structs.last;
+
+       switch(prop->type) {
+               case PROP_COLLECTION: {
+                       CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
 
-       if(begin) cprop->begin= (PropCollectionBeginFunc)begin;
-       if(next) cprop->next= (PropCollectionNextFunc)next;
-       if(end) cprop->end= (PropCollectionEndFunc)end;
-       if(get) cprop->get= (PropCollectionGetFunc)get;
-       if(type) cprop->type= (PropCollectionTypeFunc)type;
-       if(length) cprop->length= (PropCollectionLengthFunc)length;
-       if(lookupint) cprop->lookupint= (PropCollectionLookupIntFunc)lookupint;
-       if(lookupstring) cprop->lookupstring= (PropCollectionLookupStringFunc)lookupstring;
+                       if(begin) cprop->begin= (PropCollectionBeginFunc)begin;
+                       if(next) cprop->next= (PropCollectionNextFunc)next;
+                       if(end) cprop->end= (PropCollectionEndFunc)end;
+                       if(get) cprop->get= (PropCollectionGetFunc)get;
+                       if(type) cprop->type= (PropCollectionTypeFunc)type;
+                       if(length) cprop->length= (PropCollectionLengthFunc)length;
+                       if(lookupint) cprop->lookupint= (PropCollectionLookupIntFunc)lookupint;
+                       if(lookupstring) cprop->lookupstring= (PropCollectionLookupStringFunc)lookupstring;
+                       break;
+               }
+               default:
+                       fprintf(stderr, "RNA_def_property_collection_funcs: %s.%s, type is not collection.\n", ds->srna->cname, prop->cname);
+                       DefRNA.error= 1;
+                       break;
+       }
 }