doxygen: prevent GPL license block from being parsed as doxygen comment.
[blender.git] / source / blender / makesrna / intern / rna_define.c
index 8d05cbd..97c7df2 100644 (file)
@@ -1,4 +1,4 @@
-/**
+/*
  * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
@@ -15,7 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
  * Contributor(s): Blender Foundation (2008).
  *
 #include "DNA_genfile.h"
 #include "DNA_sdna_types.h"
 
-#include "RNA_access.h"
-#include "RNA_define.h"
-#include "RNA_types.h"
-
-#include "BLI_ghash.h"
 #include "BLI_string.h"
+#include "BLI_utildefines.h"
+#include "BLI_ghash.h"
+
+#include "RNA_define.h"
 
 #include "rna_internal.h"
 
@@ -66,7 +65,7 @@ void rna_addtail(ListBase *listbase, void *vlink)
        listbase->last = link;
 }
 
-void rna_remlink(ListBase *listbase, void *vlink)
+static void rna_remlink(ListBase *listbase, void *vlink)
 {
        Link *link= vlink;
 
@@ -134,7 +133,7 @@ PropertyDefRNA *rna_find_struct_property_def(StructRNA *srna, PropertyRNA *prop)
 
        if(!DefRNA.preprocess) {
                /* we should never get here */
-               fprintf(stderr, "rna_find_property_def: only at preprocess time.\n");
+               fprintf(stderr, "rna_find_struct_property_def: only at preprocess time.\n");
                return NULL;
        }
 
@@ -155,7 +154,8 @@ PropertyDefRNA *rna_find_struct_property_def(StructRNA *srna, PropertyRNA *prop)
        return NULL;
 }
 
-PropertyDefRNA *rna_find_property_def(PropertyRNA *prop)
+#if 0
+static PropertyDefRNA *rna_find_property_def(PropertyRNA *prop)
 {
        PropertyDefRNA *dprop;
 
@@ -175,6 +175,7 @@ PropertyDefRNA *rna_find_property_def(PropertyRNA *prop)
 
        return NULL;
 }
+#endif
 
 FunctionDefRNA *rna_find_function_def(FunctionRNA *func)
 {
@@ -239,7 +240,7 @@ PropertyDefRNA *rna_find_parameter_def(PropertyRNA *parm)
        return NULL;
 }
 
-ContainerDefRNA *rna_find_container_def(ContainerRNA *cont)
+static ContainerDefRNA *rna_find_container_def(ContainerRNA *cont)
 {
        StructDefRNA *ds;
        FunctionDefRNA *dfunc;
@@ -264,8 +265,8 @@ ContainerDefRNA *rna_find_container_def(ContainerRNA *cont)
 /* DNA utility function for looking up members */
 
 typedef struct DNAStructMember {
-       char *type;
-       char *name;
+       const char *type;
+       const char *name;
        int arraylength;
        int pointerlevel;
 } DNAStructMember;
@@ -295,7 +296,7 @@ static int rna_member_cmp(const char *name, const char *oname)
 
 static int rna_find_sdna_member(SDNA *sdna, const char *structname, const char *membername, DNAStructMember *smember)
 {
-       char *dnaname;
+       const char *dnaname;
        short *sp;
        int a, b, structnr, totmember, cmp;
 
@@ -359,7 +360,7 @@ static int rna_validate_identifier(const char *identifier, char *error, int prop
        int a=0;
        
        /*  list from http://docs.python.org/reference/lexical_analysis.html#id5 */
-       static char *kwlist[] = {
+       static const char *kwlist[] = {
                "and", "as", "assert", "break",
                "class", "continue", "def", "del",
                "elif", "else", "except", "exec",
@@ -411,7 +412,7 @@ static int rna_validate_identifier(const char *identifier, char *error, int prop
 
 /* Blender Data Definition */
 
-BlenderRNA *RNA_create()
+BlenderRNA *RNA_create(void)
 {
        BlenderRNA *brna;
 
@@ -474,11 +475,12 @@ void RNA_struct_free(BlenderRNA *brna, StructRNA *srna)
        PropertyRNA *prop, *nextprop;
        PropertyRNA *parm, *nextparm;
 
+       /*
        if(srna->flag & STRUCT_RUNTIME) {
                if(RNA_struct_py_type_get(srna)) {
-                       fprintf(stderr, "StructRNA \"%s\" freed while holdng a python reference\n", srna->name);
+                       fprintf(stderr, "RNA_struct_free '%s' freed while holding a python reference\n", srna->identifier);
                }
-       }
+       } */
 
        for(prop=srna->cont.properties.first; prop; prop=nextprop) {
                nextprop= prop->next;
@@ -648,11 +650,11 @@ StructRNA *RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *
                /* define some builtin properties */
                prop= RNA_def_property(&srna->cont, "rna_properties", PROP_COLLECTION, PROP_NONE);
                RNA_def_property_flag(prop, PROP_BUILTIN);
-               RNA_def_property_ui_text(prop, "Properties", "RNA property collection.");
+               RNA_def_property_ui_text(prop, "Properties", "RNA property collection");
 
                if(DefRNA.preprocess) {
                        RNA_def_property_struct_type(prop, "Property");
-                       RNA_def_property_collection_funcs(prop, "rna_builtin_properties_begin", "rna_builtin_properties_next", "rna_iterator_listbase_end", "rna_builtin_properties_get", 0, 0, "rna_builtin_properties_lookup_string", 0, 0);
+                       RNA_def_property_collection_funcs(prop, "rna_builtin_properties_begin", "rna_builtin_properties_next", "rna_iterator_listbase_end", "rna_builtin_properties_get", 0, 0, "rna_builtin_properties_lookup_string");
                }
                else {
 #ifdef RNA_RUNTIME
@@ -660,16 +662,17 @@ StructRNA *RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *
                        cprop->begin= rna_builtin_properties_begin;
                        cprop->next= rna_builtin_properties_next;
                        cprop->get= rna_builtin_properties_get;
-                       cprop->type= &RNA_Property;
+                       cprop->item_type= &RNA_Property;
 #endif
                }
 
                prop= RNA_def_property(&srna->cont, "rna_type", PROP_POINTER, PROP_NONE);
-               RNA_def_property_ui_text(prop, "RNA", "RNA type definition.");
+               RNA_def_property_flag(prop, PROP_HIDDEN);
+               RNA_def_property_ui_text(prop, "RNA", "RNA type definition");
 
                if(DefRNA.preprocess) {
                        RNA_def_property_struct_type(prop, "Struct");
-                       RNA_def_property_pointer_funcs(prop, "rna_builtin_type_get", NULL, NULL);
+                       RNA_def_property_pointer_funcs(prop, "rna_builtin_type_get", NULL, NULL, NULL);
                }
                else {
 #ifdef RNA_RUNTIME
@@ -736,7 +739,7 @@ void RNA_def_struct_sdna_from(StructRNA *srna, const char *structname, const cha
 void RNA_def_struct_name_property(struct StructRNA *srna, struct PropertyRNA *prop)
 {
        if(prop->type != PROP_STRING) {
-               fprintf(stderr, "RNA_def_struct_name_property: %s.%s, must be a string property.\n", srna->identifier, prop->identifier);
+               fprintf(stderr, "RNA_def_struct_name_property: \"%s.%s\", must be a string property.\n", srna->identifier, prop->identifier);
                DefRNA.error= 1;
        }
        else
@@ -780,10 +783,10 @@ void RNA_def_struct_refine_func(StructRNA *srna, const char *refine)
        if(refine) srna->refine= (StructRefineFunc)refine;
 }
 
-void RNA_def_struct_idproperties_func(StructRNA *srna, const char *idproperties)
+void RNA_def_struct_idprops_func(StructRNA *srna, const char *idproperties)
 {
        if(!DefRNA.preprocess) {
-               fprintf(stderr, "RNA_def_struct_idproperties_func: only during preprocessing.\n");
+               fprintf(stderr, "RNA_def_struct_idprops_func: only during preprocessing.\n");
                return;
        }
 
@@ -836,7 +839,7 @@ void RNA_def_struct_ui_icon(StructRNA *srna, int icon)
 
 PropertyRNA *RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier, int type, int subtype)
 {
-       StructRNA *srna= DefRNA.laststruct;
+       /*StructRNA *srna= DefRNA.laststruct;*/ /* invalid for python defined props */
        ContainerRNA *cont= cont_;
        ContainerDefRNA *dcont;
        PropertyDefRNA *dprop= NULL;
@@ -846,7 +849,7 @@ PropertyRNA *RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier
                char error[512];
                
                if (rna_validate_identifier(identifier, error, 1) == 0) {
-                       fprintf(stderr, "RNA_def_property: property identifier \"%s\" - %s\n", identifier, error);
+                       fprintf(stderr, "RNA_def_property: property identifier \"%s.%s\" - %s\n", CONTAINER_RNA_ID(cont), identifier, error);
                        DefRNA.error= 1;
                }
                
@@ -854,7 +857,7 @@ PropertyRNA *RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier
 
                /* XXX - toto, detect supertype collisions */
                if(rna_findlink(&dcont->properties, identifier)) {
-                       fprintf(stderr, "RNA_def_property: duplicate identifier \"%s\"\n", identifier);
+                       fprintf(stderr, "RNA_def_property: duplicate identifier \"%s.%s\"\n", CONTAINER_RNA_ID(cont), identifier);
                        DefRNA.error= 1;
                }
 
@@ -884,11 +887,11 @@ PropertyRNA *RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier
                        fprop->hardmin= (subtype == PROP_UNSIGNED)? 0.0f: -FLT_MAX;
                        fprop->hardmax= FLT_MAX;
 
-                       if(subtype == PROP_COLOR) {
+                       if(ELEM(subtype, PROP_COLOR, PROP_COLOR_GAMMA)) {
                                fprop->softmin= 0.0f;
                                fprop->softmax= 1.0f;
                        }
-                       else if(subtype == PROP_PERCENTAGE) {
+                       else if(subtype == PROP_FACTOR) {
                                fprop->softmin= fprop->hardmin= 0.0f;
                                fprop->softmax= fprop->hardmax= 1.0f;
                        }
@@ -912,7 +915,7 @@ PropertyRNA *RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier
                case PROP_COLLECTION:
                        break;
                default:
-                       fprintf(stderr, "RNA_def_property: %s.%s, invalid property type.\n", srna->identifier, identifier);
+                       fprintf(stderr, "RNA_def_property: \"%s.%s\", invalid property type.\n", CONTAINER_RNA_ID(cont), identifier);
                        DefRNA.error= 1;
                        return NULL;
        }
@@ -928,12 +931,14 @@ PropertyRNA *RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier
        prop->subtype= subtype;
        prop->name= identifier;
        prop->description= "";
+       /* a priori not raw editable */
+       prop->rawtype = -1;
 
        if(type != PROP_COLLECTION && type != PROP_POINTER) {
                prop->flag= PROP_EDITABLE;
        
                if(type != PROP_STRING)
-                       prop->flag |= PROP_ANIMATEABLE;
+                       prop->flag |= PROP_ANIMATABLE;
        }
 
        if(DefRNA.preprocess) {
@@ -1001,18 +1006,29 @@ void RNA_def_property_clear_flag(PropertyRNA *prop, int flag)
        prop->flag &= ~flag;
 }
 
+void RNA_def_property_subtype(PropertyRNA *prop, PropertySubType subtype)
+{
+       prop->subtype= subtype;
+}
+
 void RNA_def_property_array(PropertyRNA *prop, int length)
 {
        StructRNA *srna= DefRNA.laststruct;
 
        if(length<0) {
-               fprintf(stderr, "RNA_def_property_array: %s.%s, array length must be zero of greater.\n", srna->identifier, prop->identifier);
+               fprintf(stderr, "RNA_def_property_array: \"%s.%s\", array length must be zero of greater.\n", srna->identifier, prop->identifier);
                DefRNA.error= 1;
                return;
        }
 
        if(length>RNA_MAX_ARRAY_LENGTH) {
-               fprintf(stderr, "RNA_def_property_array: %s.%s, array length must be smaller than %d.\n", srna->identifier, prop->identifier, RNA_MAX_ARRAY_LENGTH);
+               fprintf(stderr, "RNA_def_property_array: \"%s.%s\", array length must be smaller than %d.\n", srna->identifier, prop->identifier, RNA_MAX_ARRAY_LENGTH);
+               DefRNA.error= 1;
+               return;
+       }
+
+       if(prop->arraydimension > 1) {
+               fprintf(stderr, "RNA_def_property_array: \"%s.%s\", array dimensions has been set to %d but would be overwritten as 1.\n", srna->identifier, prop->identifier, prop->arraydimension);
                DefRNA.error= 1;
                return;
        }
@@ -1026,19 +1042,19 @@ void RNA_def_property_array(PropertyRNA *prop, int length)
                        prop->arraydimension= 1;
                        break;
                default:
-                       fprintf(stderr, "RNA_def_property_array: %s.%s, only boolean/int/float can be array.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_array: \"%s.%s\", only boolean/int/float can be array.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
 }
 
-void RNA_def_property_multi_array(PropertyRNA *prop, int dimension, int length[])
+void RNA_def_property_multi_array(PropertyRNA *prop, int dimension, const int length[])
 {
        StructRNA *srna= DefRNA.laststruct;
        int i;
        
        if (dimension < 1 || dimension > RNA_MAX_ARRAY_DIMENSION) {
-               fprintf(stderr, "RNA_def_property_multi_array: %s.%s, array dimension must be between 1 and %d.\n", srna->identifier, prop->identifier, RNA_MAX_ARRAY_DIMENSION);
+               fprintf(stderr, "RNA_def_property_multi_array: \"%s.%s\", array dimension must be between 1 and %d.\n", srna->identifier, prop->identifier, RNA_MAX_ARRAY_DIMENSION);
                DefRNA.error= 1;
                return;
        }
@@ -1049,7 +1065,7 @@ void RNA_def_property_multi_array(PropertyRNA *prop, int dimension, int length[]
                case PROP_FLOAT:
                        break;
                default:
-                       fprintf(stderr, "RNA_def_property_multi_array: %s.%s, only boolean/int/float can be array.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_multi_array: \"%s.%s\", only boolean/int/float can be array.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1104,7 +1120,7 @@ void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_ui_range: %s.%s, invalid type for ui range.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_ui_range: \"%s.%s\", invalid type for ui range.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1132,7 +1148,7 @@ void RNA_def_property_range(PropertyRNA *prop, double min, double max)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_range: %s.%s, invalid type for range.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_range: \"%s.%s\", invalid type for range.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1143,7 +1159,7 @@ void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
        StructRNA *srna= DefRNA.laststruct;
 
        if(!DefRNA.preprocess) {
-               fprintf(stderr, "RNA_def_property_struct_type %s.%s: only during preprocessing.\n", srna->identifier, prop->identifier);
+               fprintf(stderr, "RNA_def_property_struct_type \"%s.%s\": only during preprocessing.\n", srna->identifier, prop->identifier);
                return;
        }
 
@@ -1155,11 +1171,11 @@ void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
                }
                case PROP_COLLECTION: {
                        CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
-                       cprop->type = (StructRNA*)type;
+                       cprop->item_type = (StructRNA*)type;
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_struct_type: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_struct_type: \"%s.%s\", invalid type for struct type.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1186,11 +1202,11 @@ void RNA_def_property_struct_runtime(PropertyRNA *prop, StructRNA *type)
                }
                case PROP_COLLECTION: {
                        CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
-                       cprop->type = type;
+                       cprop->item_type = type;
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_struct_runtime: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_struct_runtime: \"%s.%s\", invalid type for struct type.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1225,7 +1241,7 @@ void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_enum_items: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_enum_items: \"%s.%s\", invalid type for struct type.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1242,7 +1258,7 @@ void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_string_maxlength: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_string_maxlength: \"%s.%s\", type is not string.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1259,7 +1275,7 @@ void RNA_def_property_boolean_default(PropertyRNA *prop, int value)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_boolean_default: \"%s.%s\", type is not boolean.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1276,7 +1292,7 @@ void RNA_def_property_boolean_array_default(PropertyRNA *prop, const int *array)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_boolean_default: \"%s.%s\", type is not boolean.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1293,7 +1309,7 @@ void RNA_def_property_int_default(PropertyRNA *prop, int value)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_int_default: \"%s.%s\", type is not int.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1310,7 +1326,7 @@ void RNA_def_property_int_array_default(PropertyRNA *prop, const int *array)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_int_default: \"%s.%s\", type is not int.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1327,7 +1343,7 @@ void RNA_def_property_float_default(PropertyRNA *prop, float value)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_float_default: \"%s.%s\", type is not float.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1344,7 +1360,7 @@ void RNA_def_property_float_array_default(PropertyRNA *prop, const float *array)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_float_default: \"%s.%s\", type is not float.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1361,7 +1377,7 @@ void RNA_def_property_string_default(PropertyRNA *prop, const char *value)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_string_default: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_string_default: \"%s.%s\", type is not string.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1377,25 +1393,41 @@ void RNA_def_property_enum_default(PropertyRNA *prop, int value)
                        EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
                        eprop->defaultvalue= value;
 
-                       for(i=0; i<eprop->totitem; i++) {
-                               if(eprop->item[i].identifier[0] && eprop->item[i].value == eprop->defaultvalue)
-                                       defaultfound= 1;
-                       }
-
-                       if(!defaultfound && eprop->totitem) {
-                               if(value == 0) {
-                                       eprop->defaultvalue= eprop->item[0].value;
+                       if(prop->flag & PROP_ENUM_FLAG) {
+                               /* check all bits are accounted for */
+                               int totflag= 0;
+                               for(i=0; i<eprop->totitem; i++) {
+                                       if(eprop->item[i].identifier[0]) {
+                                               totflag |= eprop->item[i].value;
+                                       }
                                }
-                               else {
-                                       fprintf(stderr, "RNA_def_property_enum_default: %s.%s, default is not in items.\n", srna->identifier, prop->identifier);
+
+                               if(eprop->defaultvalue & ~totflag) {
+                                       fprintf(stderr, "RNA_def_property_enum_default: \"%s.%s\", default includes unused bits (%d).\n", srna->identifier, prop->identifier, eprop->defaultvalue & ~totflag);
                                        DefRNA.error= 1;
                                }
                        }
+                       else {
+                               for(i=0; i<eprop->totitem; i++) {
+                                       if(eprop->item[i].identifier[0] && eprop->item[i].value == eprop->defaultvalue)
+                                               defaultfound= 1;
+                               }
+
+                               if(!defaultfound && eprop->totitem) {
+                                       if(value == 0) {
+                                               eprop->defaultvalue= eprop->item[0].value;
+                                       }
+                                       else {
+                                               fprintf(stderr, "RNA_def_property_enum_default: \"%s.%s\", default is not in items.\n", srna->identifier, prop->identifier);
+                                               DefRNA.error= 1;
+                                       }
+                               }
+                       }
 
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_enum_default: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_enum_default: \"%s.%s\", type is not enum.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1434,7 +1466,7 @@ static PropertyDefRNA *rna_def_property_sdna(PropertyRNA *prop, const char *stru
                        return dp;
                }
                else {
-                       fprintf(stderr, "rna_def_property_sdna: %s.%s not found.\n", structname, propname);
+                       fprintf(stderr, "rna_def_property_sdna: \"%s.%s\" not found.\n", structname, propname);
                        DefRNA.error= 1;
                        return NULL;
                }
@@ -1472,13 +1504,24 @@ void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, co
        }
 
        if(prop->type != PROP_BOOLEAN) {
-               fprintf(stderr, "RNA_def_property_boolean_sdna: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
+               fprintf(stderr, "RNA_def_property_boolean_sdna: \"%s.%s\", type is not boolean.\n", srna->identifier, prop->identifier);
                DefRNA.error= 1;
                return;
        }
 
-       if((dp=rna_def_property_sdna(prop, structname, propname)))
+       if((dp=rna_def_property_sdna(prop, structname, propname))) {
+
+               if(DefRNA.silent == 0) {
+                       /* error check to ensure floats are not wrapped as ints/bools */
+                       if(dp->dnatype && *dp->dnatype && IS_DNATYPE_INT_COMPAT(dp->dnatype) == 0) {
+                               fprintf(stderr, "RNA_def_property_boolean_sdna: %s.%s is a '%s' but wrapped as type '%s'.\n", srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
+                               DefRNA.error= 1;
+                               return;
+                       }
+               }
+
                dp->booleanbit= bit;
+       }
 }
 
 void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname, const char *propname, int booleanbit)
@@ -1505,12 +1548,22 @@ void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const
        }
 
        if(prop->type != PROP_INT) {
-               fprintf(stderr, "RNA_def_property_int_sdna: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
+               fprintf(stderr, "RNA_def_property_int_sdna: \"%s.%s\", type is not int.\n", srna->identifier, prop->identifier);
                DefRNA.error= 1;
                return;
        }
 
        if((dp= rna_def_property_sdna(prop, structname, propname))) {
+
+               /* error check to ensure floats are not wrapped as ints/bools */
+               if(DefRNA.silent == 0) {
+                       if(dp->dnatype && *dp->dnatype && IS_DNATYPE_INT_COMPAT(dp->dnatype) == 0) {
+                               fprintf(stderr, "RNA_def_property_int_sdna: %s.%s is a '%s' but wrapped as type '%s'.\n", srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
+                               DefRNA.error= 1;
+                               return;
+                       }
+               }
+
                /* SDNA doesn't pass us unsigned unfortunately .. */
                if(dp->dnatype && strcmp(dp->dnatype, "char") == 0) {
                        iprop->hardmin= iprop->softmin= CHAR_MIN;
@@ -1528,13 +1581,14 @@ void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const
                        iprop->softmax= 10000;
                }
 
-               if(prop->subtype == PROP_UNSIGNED || prop->subtype == PROP_PERCENTAGE)
+               if(prop->subtype == PROP_UNSIGNED || prop->subtype == PROP_PERCENTAGE || prop->subtype == PROP_FACTOR)
                        iprop->hardmin= iprop->softmin= 0;
        }
 }
 
 void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname)
 {
+       PropertyDefRNA *dp;
        StructRNA *srna= DefRNA.laststruct;
 
        if(!DefRNA.preprocess) {
@@ -1543,17 +1597,30 @@ void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, cons
        }
 
        if(prop->type != PROP_FLOAT) {
-               fprintf(stderr, "RNA_def_property_float_sdna: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
+               fprintf(stderr, "RNA_def_property_float_sdna: \"%s.%s\", type is not float.\n", srna->identifier, prop->identifier);
                DefRNA.error= 1;
                return;
        }
 
+       if((dp= rna_def_property_sdna(prop, structname, propname))) {
+               /* silent is for internal use */
+               if(DefRNA.silent == 0) {
+                       if(dp->dnatype && *dp->dnatype && IS_DNATYPE_FLOAT_COMPAT(dp->dnatype) == 0) {
+                               if(prop->subtype != PROP_COLOR_GAMMA) { /* colors are an exception. these get translated */
+                                       fprintf(stderr, "RNA_def_property_float_sdna: %s.%s is a '%s' but wrapped as type '%s'.\n", srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
+                                       DefRNA.error= 1;
+                                       return;
+                               }
+                       }
+               }
+       }
+
        rna_def_property_sdna(prop, structname, propname);
 }
 
 void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname)
 {
-       PropertyDefRNA *dp;
+       /* PropertyDefRNA *dp; */
        StructRNA *srna= DefRNA.laststruct;
        
        if(!DefRNA.preprocess) {
@@ -1562,18 +1629,18 @@ void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const
        }
 
        if(prop->type != PROP_ENUM) {
-               fprintf(stderr, "RNA_def_property_enum_sdna: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
+               fprintf(stderr, "RNA_def_property_enum_sdna: \"%s.%s\", type is not enum.\n", srna->identifier, prop->identifier);
                DefRNA.error= 1;
                return;
        }
 
-       if((dp=rna_def_property_sdna(prop, structname, propname))) {
+       if(( /* dp= */ rna_def_property_sdna(prop, structname, propname))) {
                if(prop->arraydimension) {
                        prop->arraydimension= 0;
                        prop->totarraylength= 0;
 
                        if(!DefRNA.silent) {
-                               fprintf(stderr, "RNA_def_property_enum_sdna: %s.%s, array not supported for enum type.\n", structname, propname);
+                               fprintf(stderr, "RNA_def_property_enum_sdna: \"%s.%s\", array not supported for enum type.\n", structname, propname);
                                DefRNA.error= 1;
                        }
                }
@@ -1594,7 +1661,7 @@ void RNA_def_property_enum_bitflag_sdna(PropertyRNA *prop, const char *structnam
 
 void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, const char *propname)
 {
-       PropertyDefRNA *dp;
+       /* PropertyDefRNA *dp; */
        StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
        StructRNA *srna= DefRNA.laststruct;
 
@@ -1604,12 +1671,12 @@ void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, con
        }
 
        if(prop->type != PROP_STRING) {
-               fprintf(stderr, "RNA_def_property_string_sdna: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
+               fprintf(stderr, "RNA_def_property_string_sdna: \"%s.%s\", type is not string.\n", srna->identifier, prop->identifier);
                DefRNA.error= 1;
                return;
        }
 
-       if((dp=rna_def_property_sdna(prop, structname, propname))) {
+       if((/* dp= */ rna_def_property_sdna(prop, structname, propname))) {
                if(prop->arraydimension) {
                        sprop->maxlength= prop->totarraylength;
                        prop->arraydimension= 0;
@@ -1620,7 +1687,7 @@ void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, con
 
 void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname)
 {
-       PropertyDefRNA *dp;
+       /* PropertyDefRNA *dp; */
        StructRNA *srna= DefRNA.laststruct;
        
        if(!DefRNA.preprocess) {
@@ -1629,18 +1696,18 @@ void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, co
        }
 
        if(prop->type != PROP_POINTER) {
-               fprintf(stderr, "RNA_def_property_pointer_sdna: %s.%s, type is not pointer.\n", srna->identifier, prop->identifier);
+               fprintf(stderr, "RNA_def_property_pointer_sdna: \"%s.%s\", type is not pointer.\n", srna->identifier, prop->identifier);
                DefRNA.error= 1;
                return;
        }
 
-       if((dp=rna_def_property_sdna(prop, structname, propname))) {
+       if((/* dp= */ rna_def_property_sdna(prop, structname, propname))) {
                if(prop->arraydimension) {
                        prop->arraydimension= 0;
                        prop->totarraylength= 0;
 
                        if(!DefRNA.silent) {
-                               fprintf(stderr, "RNA_def_property_pointer_sdna: %s.%s, array not supported for pointer type.\n", structname, propname);
+                               fprintf(stderr, "RNA_def_property_pointer_sdna: \"%s.%s\", array not supported for pointer type.\n", structname, propname);
                                DefRNA.error= 1;
                        }
                }
@@ -1659,7 +1726,7 @@ void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname,
        }
 
        if(prop->type != PROP_COLLECTION) {
-               fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s, type is not collection.\n", srna->identifier, prop->identifier);
+               fprintf(stderr, "RNA_def_property_collection_sdna: \"%s.%s\", type is not collection.\n", srna->identifier, prop->identifier);
                DefRNA.error= 1;
                return;
        }
@@ -1670,7 +1737,7 @@ void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname,
                        prop->totarraylength= 0;
 
                        if(!DefRNA.silent) {
-                               fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s, array of collections not supported.\n", structname, propname);
+                               fprintf(stderr, "RNA_def_property_collection_sdna: \"%s.%s\", array of collections not supported.\n", structname, propname);
                                DefRNA.error= 1;
                        }
                }
@@ -1698,6 +1765,7 @@ void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname,
                        else {
                                dp->dnalengthstructname= structname;
                                dp->dnalengthname= lengthpropname;
+                               prop->totarraylength= 0;
                        }
 
                        cprop->next= (PropCollectionNextFunc)"rna_iterator_array_next";
@@ -1710,7 +1778,7 @@ void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname,
                }
                else {
                        if(!DefRNA.silent) {
-                               fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s not found.\n", structname, lengthpropname);
+                               fprintf(stderr, "RNA_def_property_collection_sdna: \"%s.%s\" not found.\n", structname, lengthpropname);
                                DefRNA.error= 1;
                        }
                }
@@ -1729,6 +1797,16 @@ void RNA_def_property_editable_func(PropertyRNA *prop, const char *editable)
        if(editable) prop->editable= (EditableFunc)editable;
 }
 
+void RNA_def_property_editable_array_func(PropertyRNA *prop, const char *editable)
+{
+       if(!DefRNA.preprocess) {
+               fprintf(stderr, "RNA_def_property_editable_array_func: only during preprocessing.\n");
+               return;
+       }
+
+       if(editable) prop->itemeditable= (ItemEditableFunc)editable;
+}
+
 void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *func)
 {
        if(!DefRNA.preprocess) {
@@ -1780,7 +1858,7 @@ void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const ch
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_boolean_funcs: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_boolean_funcs: \"%s.%s\", type is not boolean.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1811,7 +1889,7 @@ void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_int_funcs: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_int_funcs: \"%s.%s\", type is not int.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1842,7 +1920,7 @@ void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_float_funcs: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_float_funcs: \"%s.%s\", type is not float.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1867,7 +1945,7 @@ void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_enum_funcs: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_enum_funcs: \"%s.%s\", type is not enum.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -1892,13 +1970,13 @@ void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const cha
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_string_funcs: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_string_funcs: \"%s.%s\", type is not string.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
 }
 
-void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set, const char *typef)
+void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set, const char *typef, const char *poll)
 {
        StructRNA *srna= DefRNA.laststruct;
 
@@ -1914,16 +1992,17 @@ void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const ch
                        if(get) pprop->get= (PropPointerGetFunc)get;
                        if(set) pprop->set= (PropPointerSetFunc)set;
                        if(typef) pprop->typef= (PropPointerTypeFunc)typef;
+                       if(poll) pprop->poll= (PropPointerPollFunc)poll;
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_pointer_funcs: %s.%s, type is not pointer.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_pointer_funcs: \"%s.%s\", type is not pointer.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
 }
 
-void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, const char *next, const char *end, const char *get, const char *length, const char *lookupint, const char *lookupstring, const char *add, const char *remove)
+void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, const char *next, const char *end, const char *get, const char *length, const char *lookupint, const char *lookupstring)
 {
        StructRNA *srna= DefRNA.laststruct;
 
@@ -1943,17 +2022,20 @@ void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, con
                        if(length) cprop->length= (PropCollectionLengthFunc)length;
                        if(lookupint) cprop->lookupint= (PropCollectionLookupIntFunc)lookupint;
                        if(lookupstring) cprop->lookupstring= (PropCollectionLookupStringFunc)lookupstring;
-                       if(add) cprop->add= (FunctionRNA*)add;
-                       if(remove) cprop->remove= (FunctionRNA*)remove;
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_collection_funcs: %s.%s, type is not collection.\n", srna->identifier, prop->identifier);
+                       fprintf(stderr, "RNA_def_property_collection_funcs: \"%s.%s\", type is not collection.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
 }
 
+void RNA_def_property_srna(PropertyRNA *prop, const char *type)
+{
+       prop->srna= (StructRNA*)type;
+}
+
 /* Compact definitions */
 
 PropertyRNA *RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, int default_value, const char *ui_name, const char *ui_description)
@@ -2113,11 +2195,30 @@ PropertyRNA *RNA_def_string_dir_path(StructOrFunctionRNA *cont_, const char *ide
        return prop;
 }
 
+PropertyRNA *RNA_def_string_file_name(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, int maxlen, 
+       const char *ui_name, const char *ui_description)
+{
+       ContainerRNA *cont= cont_;
+       PropertyRNA *prop;
+       
+       prop= RNA_def_property(cont, identifier, PROP_STRING, PROP_FILENAME);
+       if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
+       if(default_value) RNA_def_property_string_default(prop, default_value);
+       RNA_def_property_ui_text(prop, ui_name, ui_description);
+
+       return prop;
+}
+
 PropertyRNA *RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, int default_value, 
        const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont= cont_;
        PropertyRNA *prop;
+
+       if(!items) {
+               printf("RNA_def_enum: items not allowed to be NULL.\n");
+               return NULL;
+       }
        
        prop= RNA_def_property(cont, identifier, PROP_ENUM, PROP_NONE);
        if(items) RNA_def_property_enum_items(prop, items);
@@ -2127,6 +2228,27 @@ PropertyRNA *RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, co
        return prop;
 }
 
+/* same as above but sets 'PROP_ENUM_FLAG' before setting the default value */
+PropertyRNA *RNA_def_enum_flag(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, int default_value,
+       const char *ui_name, const char *ui_description)
+{
+       ContainerRNA *cont= cont_;
+       PropertyRNA *prop;
+
+       if(!items) {
+               printf("RNA_def_enum_flag: items not allowed to be NULL.\n");
+               return NULL;
+       }
+
+       prop= RNA_def_property(cont, identifier, PROP_ENUM, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_ENUM_FLAG); /* important to run before default set */
+       if(items) RNA_def_property_enum_items(prop, items);
+       RNA_def_property_enum_default(prop, default_value);
+       RNA_def_property_ui_text(prop, ui_name, ui_description);
+
+       return prop;
+}
+
 void RNA_def_enum_funcs(PropertyRNA *prop, EnumPropertyItemFunc itemfunc)
 {
        EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
@@ -2164,6 +2286,17 @@ PropertyRNA *RNA_def_float_vector(StructOrFunctionRNA *cont_, const char *identi
        return prop;
 }
 
+PropertyRNA *RNA_def_float_vector_xyz(StructOrFunctionRNA *cont_, const char *identifier, int len, const float *default_value, 
+       float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
+{
+       PropertyRNA *prop;
+       
+       prop= RNA_def_float_vector(cont_, identifier, len, default_value, hardmin, hardmax, ui_name, ui_description, softmin, softmax);
+       prop->subtype = PROP_XYZ_LENGTH;
+
+       return prop;
+}
+
 PropertyRNA *RNA_def_float_color(StructOrFunctionRNA *cont_, const char *identifier, int len, const float *default_value, 
        float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
 {
@@ -2186,8 +2319,11 @@ PropertyRNA *RNA_def_float_matrix(StructOrFunctionRNA *cont_, const char *identi
 {
        ContainerRNA *cont= cont_;
        PropertyRNA *prop;
-       int length[2]= {rows, columns};
-       
+       int length[2];
+
+       length[0]= rows;
+       length[1]= columns;
+
        prop= RNA_def_property(cont, identifier, PROP_FLOAT, PROP_MATRIX);
        RNA_def_property_multi_array(prop, 2, length);
        if(default_value) RNA_def_property_float_array_default(prop, default_value);
@@ -2245,6 +2381,21 @@ PropertyRNA *RNA_def_float_percentage(StructOrFunctionRNA *cont_, const char *id
        return prop;
 }
 
+PropertyRNA *RNA_def_float_factor(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
+       float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
+{
+       ContainerRNA *cont= cont_;
+       PropertyRNA *prop;
+       
+       prop= RNA_def_property(cont, identifier, PROP_FLOAT, PROP_FACTOR);
+       RNA_def_property_float_default(prop, default_value);
+       if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
+       RNA_def_property_ui_text(prop, ui_name, ui_description);
+       RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
+
+       return prop;
+}
+
 PropertyRNA *RNA_def_pointer(StructOrFunctionRNA *cont_, const char *identifier, const char *type,
        const char *ui_name, const char *ui_description)
 {
@@ -2367,10 +2518,26 @@ FunctionRNA *RNA_def_function_runtime(StructRNA *srna, const char *identifier, C
        return func;
 }
 
+/* C return value only!, multiple RNA returns can be done with RNA_def_function_output */
 void RNA_def_function_return(FunctionRNA *func, PropertyRNA *ret)
 {
-       func->ret= ret;
-       ret->flag|=PROP_RETURN;
+       if (ret->flag & PROP_DYNAMIC) {
+               fprintf(stderr, "RNA_def_function_return: \"%s.%s\", dynamic values are not allowed as strict returns, use RNA_def_function_output instead.\n", func->identifier, ret->identifier);
+               return;
+       }
+       else if (ret->arraydimension) {
+               fprintf(stderr, "RNA_def_function_return: \"%s.%s\", arrays are not allowed as strict returns, use RNA_def_function_output instead.\n", func->identifier, ret->identifier);
+               return;
+       }
+
+       func->c_ret= ret;
+
+       RNA_def_function_output(func, ret);
+}
+
+void RNA_def_function_output(FunctionRNA *func, PropertyRNA *ret)
+{
+       ret->flag|= PROP_OUTPUT;
 }
 
 void RNA_def_function_flag(FunctionRNA *func, int flag)
@@ -2389,6 +2556,7 @@ int rna_parameter_size(PropertyRNA *parm)
        int len= parm->totarraylength; /* only supports fixed length at the moment */
 
        if(len > 0) {
+               /* XXX in other parts is mentioned that strings can be dynamic as well */
                if (parm->flag & PROP_DYNAMIC)
                        return sizeof(void *);
 
@@ -2411,7 +2579,12 @@ int rna_parameter_size(PropertyRNA *parm)
                        case PROP_FLOAT:
                                return sizeof(float);
                        case PROP_STRING:
-                               return sizeof(char *);
+                               /* return  valyes dont store a pointer to the original */
+                               if(parm->flag & PROP_THICK_WRAP) {
+                                       StringPropertyRNA *sparm= (StringPropertyRNA*)parm;
+                                       return sizeof(char) * sparm->maxlength;
+                               } else
+                                       return sizeof(char *);
                        case PROP_POINTER: {
 #ifdef RNA_RUNTIME
                                if(parm->flag & PROP_RNAPTR)
@@ -2433,6 +2606,18 @@ int rna_parameter_size(PropertyRNA *parm)
        return sizeof(void *);
 }
 
+/* this function returns the size of the memory allocated for the parameter,
+   useful for instance for memory alignment or for storing additional information */
+int rna_parameter_size_alloc(PropertyRNA *parm)
+{
+       int size = rna_parameter_size(parm);
+
+       if (parm->flag & PROP_DYNAMIC)
+               size+= sizeof(((ParameterDynAlloc *)NULL)->array_tot);
+
+       return size;
+}
+
 /* Dynamic Enums */
 
 void RNA_enum_item_add(EnumPropertyItem **items, int *totitem, EnumPropertyItem *item)
@@ -2520,14 +2705,26 @@ void RNA_def_func_free_pointers(FunctionRNA *func)
        }
 }
 
-void RNA_def_property_duplicate_pointers(PropertyRNA *prop)
+void RNA_def_property_duplicate_pointers(StructOrFunctionRNA *cont_, PropertyRNA *prop)
 {
+       ContainerRNA *cont= cont_;
        EnumPropertyItem *earray;
        float *farray;
        int *iarray;
        int a;
 
-       if(prop->identifier) prop->identifier= BLI_strdup(prop->identifier);
+       /* annoying since we just added this to a hash, could make this add the correct key to the hash in the first place */
+       if(prop->identifier) {
+               if(cont->prophash) {
+                       BLI_ghash_remove(cont->prophash, (void*)prop->identifier, NULL, NULL);
+                       prop->identifier= BLI_strdup(prop->identifier);
+                       BLI_ghash_insert(cont->prophash, (void*)prop->identifier, prop);
+               }
+               else {
+                       prop->identifier= BLI_strdup(prop->identifier);
+               }
+       }
+
        if(prop->name) prop->name= BLI_strdup(prop->name);
        if(prop->description) prop->description= BLI_strdup(prop->description);
 
@@ -2637,5 +2834,55 @@ void RNA_def_property_free_pointers(PropertyRNA *prop)
                }
        }
 }
+
+void RNA_def_property_free(StructOrFunctionRNA *cont_, PropertyRNA *prop)
+{
+       ContainerRNA *cont= cont_;
+       
+       if(prop->flag & PROP_RUNTIME) {
+               if(cont->prophash)
+                       BLI_ghash_remove(cont->prophash, (void*)prop->identifier, NULL, NULL);
+
+               RNA_def_property_free_pointers(prop);
+               rna_freelinkN(&cont->properties, prop);
+       }
+       else {
+               RNA_def_property_free_pointers(prop);
+       }
+}
+
+/* note: only intended for removing dynamic props */
+int RNA_def_property_free_identifier(StructOrFunctionRNA *cont_, const char *identifier)
+{
+       ContainerRNA *cont= cont_;
+       PropertyRNA *prop;
+       
+       for(prop= cont->properties.first; prop; prop= prop->next) {
+               if(strcmp(prop->identifier, identifier)==0) {
+                       if(prop->flag & PROP_RUNTIME) {
+                               RNA_def_property_free(cont_, prop);
+                               return 1;
+                       }
+                       else {
+                               return -1;
+                       }
+               }
+       }
+       return 0;
+}
 #endif
 
+const char *RNA_property_typename(PropertyType type)
+{
+       switch(type) {
+               case PROP_BOOLEAN: return "PROP_BOOLEAN";
+               case PROP_INT: return "PROP_INT";
+               case PROP_FLOAT: return "PROP_FLOAT";
+               case PROP_STRING: return "PROP_STRING";
+               case PROP_ENUM: return "PROP_ENUM";
+               case PROP_POINTER: return "PROP_POINTER";
+               case PROP_COLLECTION: return "PROP_COLLECTION";
+       }
+
+       return "PROP_UNKNOWN";
+}