Merge with trunk r37677
[blender.git] / source / blender / makesrna / intern / rna_access.c
index 15a2671..a632c5c 100644 (file)
@@ -1,4 +1,4 @@
-/**
+/*
  * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
  * ***** END GPL LICENSE BLOCK *****
  */
 
+/** \file blender/makesrna/intern/rna_access.c
+ *  \ingroup RNA
+ */
+
+
 #include <stdlib.h>
 #include <stddef.h>
 #include <string.h>
 
 #include "rna_internal.h"
 
-const PointerRNA PointerRNA_NULL= {{0}};
+const PointerRNA PointerRNA_NULL= {{NULL}};
 
 /* Init/Exit */
 
-void RNA_init()
+void RNA_init(void)
 {
        StructRNA *srna;
        PropertyRNA *prop;
@@ -77,7 +82,7 @@ void RNA_init()
        }
 }
 
-void RNA_exit()
+void RNA_exit(void)
 {
        StructRNA *srna;
 
@@ -105,7 +110,7 @@ void RNA_id_pointer_create(ID *id, PointerRNA *r_ptr)
        StructRNA *type, *idtype= NULL;
 
        if(id) {
-               PointerRNA tmp= {{0}};
+               PointerRNA tmp= {{NULL}};
                tmp.data= id;
                idtype= rna_ID_refine(&tmp);
                
@@ -235,8 +240,9 @@ IDProperty *rna_idproperty_ui(PropertyRNA *prop)
                }
        }
 
-       if (idprop)
-               return IDP_GetPropertyFromGroup(idprop, ((IDProperty *)prop)->name);
+       if (idprop) {
+               return IDP_GetPropertyTypeFromGroup(idprop, ((IDProperty *)prop)->name, IDP_GROUP);
+       }
 
        return NULL;
 }
@@ -282,7 +288,7 @@ static int rna_ensure_property_array_length(PointerRNA *ptr, PropertyRNA *prop)
        }
 }
 
-static int rna_ensure_property_array_check(PointerRNA *ptr, PropertyRNA *prop)
+static int rna_ensure_property_array_check(PointerRNA *UNUSED(ptr), PropertyRNA *prop)
 {
        if(prop->magic == RNA_MAGIC) {
                return (prop->getlength || prop->totarraylength) ? 1:0;
@@ -359,20 +365,20 @@ static int rna_idproperty_verify_valid(PointerRNA *ptr, PropertyRNA *prop, IDPro
 }
 
 static PropertyRNA *typemap[IDP_NUMTYPES] =
-       {(PropertyRNA*)&rna_IDProperty_string,
-        (PropertyRNA*)&rna_IDProperty_int,
-        (PropertyRNA*)&rna_IDProperty_float,
+       {(PropertyRNA*)&rna_PropertyGroupItem_string,
+        (PropertyRNA*)&rna_PropertyGroupItem_int,
+        (PropertyRNA*)&rna_PropertyGroupItem_float,
         NULL, NULL, NULL,
-        (PropertyRNA*)&rna_IDProperty_group, NULL,
-        (PropertyRNA*)&rna_IDProperty_double,
-        (PropertyRNA*)&rna_IDProperty_idp_array};
+        (PropertyRNA*)&rna_PropertyGroupItem_group, NULL,
+        (PropertyRNA*)&rna_PropertyGroupItem_double,
+        (PropertyRNA*)&rna_PropertyGroupItem_idp_array};
 
 static PropertyRNA *arraytypemap[IDP_NUMTYPES] =
-       {NULL, (PropertyRNA*)&rna_IDProperty_int_array,
-        (PropertyRNA*)&rna_IDProperty_float_array,
+       {NULL, (PropertyRNA*)&rna_PropertyGroupItem_int_array,
+        (PropertyRNA*)&rna_PropertyGroupItem_float_array,
         NULL, NULL, NULL,
-        (PropertyRNA*)&rna_IDProperty_collection, NULL,
-        (PropertyRNA*)&rna_IDProperty_double_array};
+        (PropertyRNA*)&rna_PropertyGroupItem_collection, NULL,
+        (PropertyRNA*)&rna_PropertyGroupItem_double_array};
 
 IDProperty *rna_idproperty_check(PropertyRNA **prop, PointerRNA *ptr)
 {
@@ -447,11 +453,10 @@ static const char *rna_ensure_property_description(PropertyRNA *prop)
                /* attempt to get the local ID values */
                IDProperty *idp_ui= rna_idproperty_ui(prop);
 
-               if(idp_ui) { /* TODO, type checking on ID props */
-
-                       IDProperty *item= IDP_GetPropertyFromGroup(idp_ui, "description");
+               if(idp_ui) {
+                       IDProperty *item= IDP_GetPropertyTypeFromGroup(idp_ui, "description", IDP_STRING);
                        if(item)
-                               return (char *)item->data.pointer ;
+                               return IDP_String(item);
                }
 
                return ((IDProperty*)prop)->name; /* XXX - not correct */
@@ -516,6 +521,24 @@ int RNA_struct_idprops_register_check(StructRNA *type)
        return (type->flag & STRUCT_NO_IDPROPERTIES) == 0;
 }
 
+/* remove an id-property */
+int RNA_struct_idprops_unset(PointerRNA *ptr, const char *identifier)
+{
+       IDProperty *group= RNA_struct_idprops(ptr, 0);
+
+       if(group) {
+               IDProperty *idp= IDP_GetPropertyFromGroup(group, identifier);
+               if(idp) {
+                       IDP_RemFromGroup(group, idp);
+                       IDP_FreeProperty(idp);
+                       MEM_freeN(idp);
+
+                       return 1;
+               }
+       }
+       return 0;
+}
+
 int RNA_struct_is_a(StructRNA *type, StructRNA *srna)
 {
        StructRNA *base;
@@ -569,6 +592,28 @@ PropertyRNA *RNA_struct_find_nested(PointerRNA *ptr, StructRNA *srna)
        return prop;
 }
 
+int RNA_struct_contains_property(PointerRNA *ptr, PropertyRNA *prop_test)
+{
+       /* note, prop_test could be freed memory, only use for comparison */
+
+       /* validate the RNA is ok */
+       PropertyRNA *iterprop;
+       int found= FALSE;
+
+       iterprop= RNA_struct_iterator_property(ptr->type);
+
+       RNA_PROP_BEGIN(ptr, itemptr, iterprop) {
+               /* PropertyRNA *prop= itemptr.data; */
+               if(prop_test == (PropertyRNA *)itemptr.data) {
+                       found= TRUE;
+                       break;
+               }
+       }
+       RNA_PROP_END;
+
+       return found;
+}
+
 /* low level direct access to type->properties, note this ignores parent classes so should be used with care */
 const struct ListBase *RNA_struct_type_properties(StructRNA *srna)
 {
@@ -616,7 +661,7 @@ FunctionRNA *RNA_struct_find_function(PointerRNA *ptr, const char *identifier)
 #endif
 }
 
-const struct ListBase *RNA_struct_defined_functions(StructRNA *srna)
+const struct ListBase *RNA_struct_type_functions(StructRNA *srna)
 {
        return &srna->functions;
 }
@@ -636,6 +681,18 @@ StructUnregisterFunc RNA_struct_unregister(StructRNA *type)
        return NULL;
 }
 
+void **RNA_struct_instance(PointerRNA *ptr)
+{
+       StructRNA *type= ptr->type;
+
+       do {
+               if(type->instance)
+                       return type->instance(ptr);
+       } while((type=type->base));
+
+       return NULL;
+}
+
 void *RNA_struct_py_type_get(StructRNA *srna)
 {
        return srna->py_type;
@@ -698,6 +755,11 @@ int RNA_property_flag(PropertyRNA *prop)
        return rna_ensure_property(prop)->flag;
 }
 
+void *RNA_property_py_data_get(PropertyRNA *prop)
+{
+       return prop->py_data;
+}
+
 int RNA_property_array_length(PointerRNA *ptr, PropertyRNA *prop)
 {
        return rna_ensure_property_array_length(ptr, prop);
@@ -739,7 +801,7 @@ char RNA_property_array_item_char(PropertyRNA *prop, int index)
        /* get string to use for array index */
        if ((index < 4) && ELEM(subtype, PROP_QUATERNION, PROP_AXISANGLE))
                return quatitem[index];
-       else if((index < 4) && ELEM7(subtype, PROP_TRANSLATION, PROP_DIRECTION, PROP_XYZ, PROP_XYZ_LENGTH, PROP_EULER, PROP_VELOCITY, PROP_ACCELERATION))
+       else if((index < 4) && ELEM8(subtype, PROP_TRANSLATION, PROP_DIRECTION, PROP_XYZ, PROP_XYZ_LENGTH, PROP_EULER, PROP_VELOCITY, PROP_ACCELERATION, PROP_COORDS))
                return vectoritem[index];
        else if ((index < 4) && ELEM(subtype, PROP_COLOR, PROP_COLOR_GAMMA))
                return coloritem[index];
@@ -751,43 +813,41 @@ int RNA_property_array_item_index(PropertyRNA *prop, char name)
 {
        PropertySubType subtype= rna_ensure_property(prop)->subtype;
 
-       name= toupper(name);
-
        /* get index based on string name/alias */
        /* maybe a function to find char index in string would be better than all the switches */
        if (ELEM(subtype, PROP_QUATERNION, PROP_AXISANGLE)) {
                switch (name) {
-                       case 'W':
+                       case 'w':
                                return 0;
-                       case 'X':
+                       case 'x':
                                return 1;
-                       case 'Y':
+                       case 'y':
                                return 2;
-                       case 'Z':
+                       case 'z':
                                return 3;
                }
        }
        else if(ELEM6(subtype, PROP_TRANSLATION, PROP_DIRECTION, PROP_XYZ, PROP_EULER, PROP_VELOCITY, PROP_ACCELERATION)) {
                switch (name) {
-                       case 'X':
+                       case 'x':
                                return 0;
-                       case 'Y':
+                       case 'y':
                                return 1;
-                       case 'Z':
+                       case 'z':
                                return 2;
-                       case 'W':
+                       case 'w':
                                return 3;
                }
        }
        else if (ELEM(subtype, PROP_COLOR, PROP_COLOR_GAMMA)) {
                switch (name) {
-                       case 'R':
+                       case 'r':
                                return 0;
-                       case 'G':
+                       case 'g':
                                return 1;
-                       case 'B':
+                       case 'b':
                                return 2;
-                       case 'A':
+                       case 'a':
                                return 3;
                }
        }
@@ -803,14 +863,15 @@ void RNA_property_int_range(PointerRNA *ptr, PropertyRNA *prop, int *hardmin, in
        if(prop->magic != RNA_MAGIC) {
                /* attempt to get the local ID values */
                IDProperty *idp_ui= rna_idproperty_ui(prop);
-               IDProperty *item;
 
-               if(idp_ui) { /* TODO, type checking on ID props */
-                       item= IDP_GetPropertyFromGroup(idp_ui, "min");
-                       *hardmin= item ? item->data.val : INT_MIN;
+               if(idp_ui) {
+                       IDProperty *item;
+
+                       item= IDP_GetPropertyTypeFromGroup(idp_ui, "min", IDP_INT);
+                       *hardmin= item ? IDP_Int(item) : INT_MIN;
 
-                       item= IDP_GetPropertyFromGroup(idp_ui, "max");
-                       *hardmax= item ? item->data.val : INT_MAX;
+                       item= IDP_GetPropertyTypeFromGroup(idp_ui, "max", IDP_INT);
+                       *hardmax= item ? IDP_Int(item) : INT_MAX;
 
                        return;
                }
@@ -833,17 +894,18 @@ void RNA_property_int_ui_range(PointerRNA *ptr, PropertyRNA *prop, int *softmin,
        if(prop->magic != RNA_MAGIC) {
                /* attempt to get the local ID values */
                IDProperty *idp_ui= rna_idproperty_ui(prop);
-               IDProperty *item;
 
-               if(idp_ui) { /* TODO, type checking on ID props */
-                       item= IDP_GetPropertyFromGroup(idp_ui, "soft_min");
-                       *softmin= item ? item->data.val : INT_MIN;
+               if(idp_ui) {
+                       IDProperty *item;
+
+                       item= IDP_GetPropertyTypeFromGroup(idp_ui, "soft_min", IDP_INT);
+                       *softmin= item ? IDP_Int(item) : INT_MIN;
 
-                       item= IDP_GetPropertyFromGroup(idp_ui, "soft_max");
-                       *softmax= item ? item->data.val : INT_MAX;
+                       item= IDP_GetPropertyTypeFromGroup(idp_ui, "soft_max", IDP_INT);
+                       *softmax= item ? IDP_Int(item) : INT_MAX;
 
-                       item= IDP_GetPropertyFromGroup(idp_ui, "step");
-                       *step= item ? item->data.val : 1;
+                       item= IDP_GetPropertyTypeFromGroup(idp_ui, "step", IDP_INT);
+                       *step= item ? IDP_Int(item) : 1;
 
                        return;
                }
@@ -869,14 +931,15 @@ void RNA_property_float_range(PointerRNA *ptr, PropertyRNA *prop, float *hardmin
        if(prop->magic != RNA_MAGIC) {
                /* attempt to get the local ID values */
                IDProperty *idp_ui= rna_idproperty_ui(prop);
-               IDProperty *item;
 
-               if(idp_ui) { /* TODO, type checking on ID props */
-                       item= IDP_GetPropertyFromGroup(idp_ui, "min");
-                       *hardmin= item ? *(double*)&item->data.val : FLT_MIN;
+               if(idp_ui) {
+                       IDProperty *item;
+
+                       item= IDP_GetPropertyTypeFromGroup(idp_ui, "min", IDP_DOUBLE);
+                       *hardmin= item ? (float)IDP_Double(item) : FLT_MIN;
 
-                       item= IDP_GetPropertyFromGroup(idp_ui, "max");
-                       *hardmax= item ? *(double*)&item->data.val : FLT_MAX;
+                       item= IDP_GetPropertyTypeFromGroup(idp_ui, "max", IDP_DOUBLE);
+                       *hardmax= item ? (float)IDP_Double(item) : FLT_MAX;
 
                        return;
                }
@@ -899,20 +962,21 @@ void RNA_property_float_ui_range(PointerRNA *ptr, PropertyRNA *prop, float *soft
        if(prop->magic != RNA_MAGIC) {
                /* attempt to get the local ID values */
                IDProperty *idp_ui= rna_idproperty_ui(prop);
-               IDProperty *item;
 
-               if(idp_ui) { /* TODO, type checking on ID props */
-                       item= IDP_GetPropertyFromGroup(idp_ui, "soft_min");
-                       *softmin= item ? *(double*)&item->data.val : FLT_MIN;
+               if(idp_ui) {
+                       IDProperty *item;
 
-                       item= IDP_GetPropertyFromGroup(idp_ui, "soft_max");
-                       *softmax= item ? *(double*)&item->data.val : FLT_MAX;
+                       item= IDP_GetPropertyTypeFromGroup(idp_ui, "soft_min", IDP_DOUBLE);
+                       *softmin= item ? (float)IDP_Double(item) : FLT_MIN;
 
-                       item= IDP_GetPropertyFromGroup(idp_ui, "step");
-                       *step= item ? *(double*)&item->data.val : 1.0f;
+                       item= IDP_GetPropertyTypeFromGroup(idp_ui, "soft_max", IDP_DOUBLE);
+                       *softmax= item ? (float)IDP_Double(item) : FLT_MAX;
 
-                       item= IDP_GetPropertyFromGroup(idp_ui, "precision");
-                       *precision= item ? *(double*)&item->data.val : 3.0f;
+                       item= IDP_GetPropertyTypeFromGroup(idp_ui, "step", IDP_DOUBLE);
+                       *step= item ? (float)IDP_Double(item) : 1.0f;
+
+                       item= IDP_GetPropertyTypeFromGroup(idp_ui, "precision", IDP_DOUBLE);
+                       *precision= item ? (float)IDP_Double(item) : 3.0f;
 
                        return;
                }
@@ -1037,9 +1101,9 @@ void RNA_property_enum_items(bContext *C, PointerRNA *ptr, PropertyRNA *prop, En
                int tot= 0;
 
                if (prop->flag & PROP_ENUM_NO_CONTEXT)
-                       *item= eprop->itemf(NULL, ptr, free);
+                       *item= eprop->itemf(NULL, ptr, prop, free);
                else
-                       *item= eprop->itemf(C, ptr, free);
+                       *item= eprop->itemf(C, ptr, prop, free);
 
                if(totitem) {
                        if(*item) {
@@ -1060,21 +1124,26 @@ int RNA_property_enum_value(bContext *C, PointerRNA *ptr, PropertyRNA *prop, con
 {      
        EnumPropertyItem *item, *item_array;
        int free, found;
-       
+
        RNA_property_enum_items(C, ptr, prop, &item_array, NULL, &free);
-       
-       for(item= item_array; item->identifier; item++) {
-               if(item->identifier[0] && strcmp(item->identifier, identifier)==0) {
-                       *value = item->value;
-                       break;
+
+       if(item_array) {
+               for(item= item_array; item->identifier; item++) {
+                       if(item->identifier[0] && strcmp(item->identifier, identifier)==0) {
+                               *value = item->value;
+                               break;
+                       }
                }
-       }
-       
-       found= (item->identifier != NULL); /* could be alloc'd, assign before free */
 
-       if(free)
-               MEM_freeN(item_array);
+               found= (item->identifier != NULL); /* could be alloc'd, assign before free */
 
+               if(free) {
+                       MEM_freeN(item_array);
+               }
+       }
+       else {
+               found= 0;
+       }
        return found;
 }
 
@@ -1240,7 +1309,7 @@ int RNA_property_animateable(PointerRNA *ptr, PropertyRNA *prop)
        return (prop->flag & PROP_EDITABLE);
 }
 
-int RNA_property_animated(PointerRNA *ptr, PropertyRNA *prop)
+int RNA_property_animated(PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop))
 {
        /* would need to ask animation system */
 
@@ -1280,7 +1349,14 @@ static void rna_property_update(bContext *C, Main *bmain, Scene *scene, PointerR
                        /* ideally no context would be needed for update, but there's some
                           parts of the code that need it still, so we have this exception */
                        if(prop->flag & PROP_CONTEXT_UPDATE) {
-                               if(C) ((ContextUpdateFunc)prop->update)(C, ptr);
+                               if(C) {
+                                       if(prop->flag & PROP_CONTEXT_PROPERTY_UPDATE) {
+                                               ((ContextPropUpdateFunc)prop->update)(C, ptr, prop);
+                                       }
+                                       else {
+                                               ((ContextUpdateFunc)prop->update)(C, ptr);
+                                       }
+                               }
                        }
                        else
                                prop->update(bmain, scene, ptr);
@@ -1322,6 +1398,8 @@ int RNA_property_boolean_get(PointerRNA *ptr, PropertyRNA *prop)
        BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_BOOLEAN);
+
        if((idprop=rna_idproperty_check(&prop, ptr)))
                return IDP_Int(idprop);
        else if(bprop->get)
@@ -1335,6 +1413,8 @@ void RNA_property_boolean_set(PointerRNA *ptr, PropertyRNA *prop, int value)
        BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_BOOLEAN);
+
        /* just incase other values are passed */
        if(value) value= 1;
 
@@ -1359,6 +1439,8 @@ void RNA_property_boolean_get_array(PointerRNA *ptr, PropertyRNA *prop, int *val
        BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_BOOLEAN);
+
        if((idprop=rna_idproperty_check(&prop, ptr))) {
                if(prop->arraydimension == 0)
                        values[0]= RNA_property_boolean_get(ptr, prop);
@@ -1380,6 +1462,8 @@ int RNA_property_boolean_get_index(PointerRNA *ptr, PropertyRNA *prop, int index
        int tmp[RNA_MAX_ARRAY_LENGTH];
        int len= rna_ensure_property_array_length(ptr, prop);
 
+       BLI_assert(RNA_property_type(prop) == PROP_BOOLEAN);
+
        if(len <= RNA_MAX_ARRAY_LENGTH) {
                RNA_property_boolean_get_array(ptr, prop, tmp);
                return tmp[index];
@@ -1401,6 +1485,8 @@ void RNA_property_boolean_set_array(PointerRNA *ptr, PropertyRNA *prop, const in
        BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_BOOLEAN);
+
        if((idprop=rna_idproperty_check(&prop, ptr))) {
                if(prop->arraydimension == 0)
                        IDP_Int(idprop)= values[0];
@@ -1432,6 +1518,8 @@ void RNA_property_boolean_set_index(PointerRNA *ptr, PropertyRNA *prop, int inde
        int tmp[RNA_MAX_ARRAY_LENGTH];
        int len= rna_ensure_property_array_length(ptr, prop);
 
+       BLI_assert(RNA_property_type(prop) == PROP_BOOLEAN);
+
        if(len <= RNA_MAX_ARRAY_LENGTH) {
                RNA_property_boolean_get_array(ptr, prop, tmp);
                tmp[index]= value;
@@ -1448,16 +1536,21 @@ void RNA_property_boolean_set_index(PointerRNA *ptr, PropertyRNA *prop, int inde
        }
 }
 
-int RNA_property_boolean_get_default(PointerRNA *ptr, PropertyRNA *prop)
+int RNA_property_boolean_get_default(PointerRNA *UNUSED(ptr), PropertyRNA *prop)
 {
        BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
+
+       BLI_assert(RNA_property_type(prop) == PROP_BOOLEAN);
+
        return bprop->defaultvalue;
 }
 
-void RNA_property_boolean_get_default_array(PointerRNA *ptr, PropertyRNA *prop, int *values)
+void RNA_property_boolean_get_default_array(PointerRNA *UNUSED(ptr), PropertyRNA *prop, int *values)
 {
        BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
        
+       BLI_assert(RNA_property_type(prop) == PROP_BOOLEAN);
+
        if(prop->arraydimension == 0)
                values[0]= bprop->defaultvalue;
        else if(bprop->defaultarray)
@@ -1471,6 +1564,8 @@ int RNA_property_boolean_get_default_index(PointerRNA *ptr, PropertyRNA *prop, i
        int tmp[RNA_MAX_ARRAY_LENGTH];
        int len= rna_ensure_property_array_length(ptr, prop);
 
+       BLI_assert(RNA_property_type(prop) == PROP_BOOLEAN);
+
        if(len <= RNA_MAX_ARRAY_LENGTH) {
                RNA_property_boolean_get_default_array(ptr, prop, tmp);
                return tmp[index];
@@ -1492,6 +1587,8 @@ int RNA_property_int_get(PointerRNA *ptr, PropertyRNA *prop)
        IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_INT);
+
        if((idprop=rna_idproperty_check(&prop, ptr)))
                return IDP_Int(idprop);
        else if(iprop->get)
@@ -1505,6 +1602,8 @@ void RNA_property_int_set(PointerRNA *ptr, PropertyRNA *prop, int value)
        IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_INT);
+
        if((idprop=rna_idproperty_check(&prop, ptr)))
                IDP_Int(idprop)= value;
        else if(iprop->set)
@@ -1526,6 +1625,8 @@ void RNA_property_int_get_array(PointerRNA *ptr, PropertyRNA *prop, int *values)
        IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_INT);
+
        if((idprop=rna_idproperty_check(&prop, ptr))) {
                if(prop->arraydimension == 0)
                        values[0]= RNA_property_int_get(ptr, prop);
@@ -1542,11 +1643,50 @@ void RNA_property_int_get_array(PointerRNA *ptr, PropertyRNA *prop, int *values)
                memset(values, 0, sizeof(int)*prop->totarraylength);
 }
 
+void RNA_property_int_get_array_range(PointerRNA *ptr, PropertyRNA *prop, int values[2])
+{
+       const int array_len= RNA_property_array_length(ptr, prop);
+
+       if(array_len <= 0) {
+               values[0]= 0;
+               values[1]= 0;
+       }
+       else if (array_len == 1) {
+               RNA_property_int_get_array(ptr, prop, values);
+               values[1]= values[0];
+       }
+       else {
+               int arr_stack[32];
+               int *arr;
+               int i;
+
+               if(array_len > 32) {
+                       arr= MEM_mallocN(sizeof(int) * array_len, "RNA_property_int_get_array_range");
+               }
+               else {
+                       arr= arr_stack;
+               }
+
+               RNA_property_int_get_array(ptr, prop, arr);
+               values[0]= values[1]= arr[0];
+               for(i= 1; i < array_len; i++) {
+                       values[0]= MIN2(values[0], arr[i]);
+                       values[1]= MAX2(values[1], arr[i]);
+               }
+
+               if(arr != arr_stack) {
+                       MEM_freeN(arr);
+               }
+       }
+}
+
 int RNA_property_int_get_index(PointerRNA *ptr, PropertyRNA *prop, int index)
 {
        int tmp[RNA_MAX_ARRAY_LENGTH];
        int len= rna_ensure_property_array_length(ptr, prop);
 
+       BLI_assert(RNA_property_type(prop) == PROP_INT);
+
        if(len <= RNA_MAX_ARRAY_LENGTH) {
                RNA_property_int_get_array(ptr, prop, tmp);
                return tmp[index];
@@ -1568,6 +1708,8 @@ void RNA_property_int_set_array(PointerRNA *ptr, PropertyRNA *prop, const int *v
        IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_INT);
+
        if((idprop=rna_idproperty_check(&prop, ptr))) {
                if(prop->arraydimension == 0)
                        IDP_Int(idprop)= values[0];
@@ -1599,6 +1741,8 @@ void RNA_property_int_set_index(PointerRNA *ptr, PropertyRNA *prop, int index, i
        int tmp[RNA_MAX_ARRAY_LENGTH];
        int len= rna_ensure_property_array_length(ptr, prop);
 
+       BLI_assert(RNA_property_type(prop) == PROP_INT);
+
        if(len <= RNA_MAX_ARRAY_LENGTH) {
                RNA_property_int_get_array(ptr, prop, tmp);
                tmp[index]= value;
@@ -1615,16 +1759,18 @@ void RNA_property_int_set_index(PointerRNA *ptr, PropertyRNA *prop, int index, i
        }
 }
 
-int RNA_property_int_get_default(PointerRNA *ptr, PropertyRNA *prop)
+int RNA_property_int_get_default(PointerRNA *UNUSED(ptr), PropertyRNA *prop)
 {
        IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
        return iprop->defaultvalue;
 }
 
-void RNA_property_int_get_default_array(PointerRNA *ptr, PropertyRNA *prop, int *values)
+void RNA_property_int_get_default_array(PointerRNA *UNUSED(ptr), PropertyRNA *prop, int *values)
 {
        IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
        
+       BLI_assert(RNA_property_type(prop) == PROP_INT);
+
        if(prop->arraydimension == 0)
                values[0]= iprop->defaultvalue;
        else if(iprop->defaultarray)
@@ -1659,6 +1805,8 @@ float RNA_property_float_get(PointerRNA *ptr, PropertyRNA *prop)
        FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_FLOAT);
+
        if((idprop=rna_idproperty_check(&prop, ptr))) {
                if(idprop->type == IDP_FLOAT)
                        return IDP_Float(idprop);
@@ -1676,6 +1824,8 @@ void RNA_property_float_set(PointerRNA *ptr, PropertyRNA *prop, float value)
        FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_FLOAT);
+
        if((idprop=rna_idproperty_check(&prop, ptr))) {
                if(idprop->type == IDP_FLOAT)
                        IDP_Float(idprop)= value;
@@ -1703,6 +1853,8 @@ void RNA_property_float_get_array(PointerRNA *ptr, PropertyRNA *prop, float *val
        IDProperty *idprop;
        int i;
 
+       BLI_assert(RNA_property_type(prop) == PROP_FLOAT);
+
        if((idprop=rna_idproperty_check(&prop, ptr))) {
                if(prop->arraydimension == 0)
                        values[0]= RNA_property_float_get(ptr, prop);
@@ -1724,11 +1876,50 @@ void RNA_property_float_get_array(PointerRNA *ptr, PropertyRNA *prop, float *val
                memset(values, 0, sizeof(float)*prop->totarraylength);
 }
 
+void RNA_property_float_get_array_range(PointerRNA *ptr, PropertyRNA *prop, float values[2])
+{
+       const int array_len= RNA_property_array_length(ptr, prop);
+
+       if(array_len <= 0) {
+               values[0]= 0.0f;
+               values[1]= 0.0f;
+       }
+       else if (array_len == 1) {
+               RNA_property_float_get_array(ptr, prop, values);
+               values[1]= values[0];
+       }
+       else {
+               float arr_stack[32];
+               float *arr;
+               int i;
+
+               if(array_len > 32) {
+                       arr= MEM_mallocN(sizeof(float) * array_len, "RNA_property_float_get_array_range");
+               }
+               else {
+                       arr= arr_stack;
+               }
+
+               RNA_property_float_get_array(ptr, prop, arr);
+               values[0]= values[1]= arr[0];
+               for(i= 1; i < array_len; i++) {
+                       values[0]= MIN2(values[0], arr[i]);
+                       values[1]= MAX2(values[1], arr[i]);
+               }
+
+               if(arr != arr_stack) {
+                       MEM_freeN(arr);
+               }
+       }
+}
+
 float RNA_property_float_get_index(PointerRNA *ptr, PropertyRNA *prop, int index)
 {
        float tmp[RNA_MAX_ARRAY_LENGTH];
        int len= rna_ensure_property_array_length(ptr, prop);
 
+       BLI_assert(RNA_property_type(prop) == PROP_FLOAT);
+
        if(len <= RNA_MAX_ARRAY_LENGTH) {
                RNA_property_float_get_array(ptr, prop, tmp);
                return tmp[index];
@@ -1752,6 +1943,8 @@ void RNA_property_float_set_array(PointerRNA *ptr, PropertyRNA *prop, const floa
        IDProperty *idprop;
        int i;
 
+       BLI_assert(RNA_property_type(prop) == PROP_FLOAT);
+
        if((idprop=rna_idproperty_check(&prop, ptr))) {
                if(prop->arraydimension == 0) {
                        if(idprop->type == IDP_FLOAT)
@@ -1793,6 +1986,8 @@ void RNA_property_float_set_index(PointerRNA *ptr, PropertyRNA *prop, int index,
        float tmp[RNA_MAX_ARRAY_LENGTH];
        int len= rna_ensure_property_array_length(ptr, prop);
 
+       BLI_assert(RNA_property_type(prop) == PROP_FLOAT);
+
        if(len <= RNA_MAX_ARRAY_LENGTH) {
                RNA_property_float_get_array(ptr, prop, tmp);
                tmp[index]= value;
@@ -1809,16 +2004,21 @@ void RNA_property_float_set_index(PointerRNA *ptr, PropertyRNA *prop, int index,
        }
 }
 
-float RNA_property_float_get_default(PointerRNA *ptr, PropertyRNA *prop)
+float RNA_property_float_get_default(PointerRNA *UNUSED(ptr), PropertyRNA *prop)
 {
        FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
+
+       BLI_assert(RNA_property_type(prop) == PROP_FLOAT);
+
        return fprop->defaultvalue;
 }
 
-void RNA_property_float_get_default_array(PointerRNA *ptr, PropertyRNA *prop, float *values)
+void RNA_property_float_get_default_array(PointerRNA *UNUSED(ptr), PropertyRNA *prop, float *values)
 {
        FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
        
+       BLI_assert(RNA_property_type(prop) == PROP_FLOAT);
+
        if(prop->arraydimension == 0)
                values[0]= fprop->defaultvalue;
        else if(fprop->defaultarray)
@@ -1832,6 +2032,8 @@ float RNA_property_float_get_default_index(PointerRNA *ptr, PropertyRNA *prop, i
        float tmp[RNA_MAX_ARRAY_LENGTH];
        int len= rna_ensure_property_array_length(ptr, prop);
 
+       BLI_assert(RNA_property_type(prop) == PROP_FLOAT);
+
        if(len <= RNA_MAX_ARRAY_LENGTH) {
                RNA_property_float_get_default_array(ptr, prop, tmp);
                return tmp[index];
@@ -1853,6 +2055,8 @@ void RNA_property_string_get(PointerRNA *ptr, PropertyRNA *prop, char *value)
        StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_STRING);
+
        if((idprop=rna_idproperty_check(&prop, ptr)))
                strcpy(value, IDP_String(idprop));
        else if(sprop->get)
@@ -1866,6 +2070,8 @@ char *RNA_property_string_get_alloc(PointerRNA *ptr, PropertyRNA *prop, char *fi
        char *buf;
        int length;
 
+       BLI_assert(RNA_property_type(prop) == PROP_STRING);
+
        length= RNA_property_string_length(ptr, prop);
 
        if(length+1 < fixedlen)
@@ -1884,6 +2090,8 @@ int RNA_property_string_length(PointerRNA *ptr, PropertyRNA *prop)
        StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_STRING);
+
        if((idprop=rna_idproperty_check(&prop, ptr)))
                return strlen(IDP_String(idprop));
        else if(sprop->length)
@@ -1897,6 +2105,8 @@ void RNA_property_string_set(PointerRNA *ptr, PropertyRNA *prop, const char *val
        StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_STRING);
+
        if((idprop=rna_idproperty_check(&prop, ptr)))
                IDP_AssignString(idprop, (char*)value, RNA_property_string_maxlength(prop) - 1);
        else if(sprop->set)
@@ -1910,9 +2120,12 @@ void RNA_property_string_set(PointerRNA *ptr, PropertyRNA *prop, const char *val
        }
 }
 
-void RNA_property_string_get_default(PointerRNA *ptr, PropertyRNA *prop, char *value)
+void RNA_property_string_get_default(PointerRNA *UNUSED(ptr), PropertyRNA *prop, char *value)
 {
        StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
+
+       BLI_assert(RNA_property_type(prop) == PROP_STRING);
+
        strcpy(value, sprop->defaultvalue);
 }
 
@@ -1921,6 +2134,8 @@ char *RNA_property_string_get_default_alloc(PointerRNA *ptr, PropertyRNA *prop,
        char *buf;
        int length;
 
+       BLI_assert(RNA_property_type(prop) == PROP_STRING);
+
        length= RNA_property_string_default_length(ptr, prop);
 
        if(length+1 < fixedlen)
@@ -1934,9 +2149,12 @@ char *RNA_property_string_get_default_alloc(PointerRNA *ptr, PropertyRNA *prop,
 }
 
 /* this is the length without \0 terminator */
-int RNA_property_string_default_length(PointerRNA *ptr, PropertyRNA *prop)
+int RNA_property_string_default_length(PointerRNA *UNUSED(ptr), PropertyRNA *prop)
 {
        StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
+
+       BLI_assert(RNA_property_type(prop) == PROP_STRING);
+
        return strlen(sprop->defaultvalue);
 }
 
@@ -1945,6 +2163,8 @@ int RNA_property_enum_get(PointerRNA *ptr, PropertyRNA *prop)
        EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_ENUM);
+
        if((idprop=rna_idproperty_check(&prop, ptr)))
                return IDP_Int(idprop);
        else if(eprop->get)
@@ -1958,6 +2178,8 @@ void RNA_property_enum_set(PointerRNA *ptr, PropertyRNA *prop, int value)
        EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_ENUM);
+
        if((idprop=rna_idproperty_check(&prop, ptr)))
                IDP_Int(idprop)= value;
        else if(eprop->set) {
@@ -1975,18 +2197,31 @@ void RNA_property_enum_set(PointerRNA *ptr, PropertyRNA *prop, int value)
        }
 }
 
-int RNA_property_enum_get_default(PointerRNA *ptr, PropertyRNA *prop)
+int RNA_property_enum_get_default(PointerRNA *UNUSED(ptr), PropertyRNA *prop)
 {
        EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
+
+       BLI_assert(RNA_property_type(prop) == PROP_ENUM);
+
        return eprop->defaultvalue;
 }
 
+void *RNA_property_enum_py_data_get(PropertyRNA *prop)
+{
+       EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
+
+       BLI_assert(RNA_property_type(prop) == PROP_ENUM);
+
+       return eprop->py_data;
+}
 
 PointerRNA RNA_property_pointer_get(PointerRNA *ptr, PropertyRNA *prop)
 {
        PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_POINTER);
+
        if((idprop=rna_idproperty_check(&prop, ptr))) {
                pprop= (PointerPropertyRNA*)prop;
 
@@ -2011,6 +2246,8 @@ void RNA_property_pointer_set(PointerRNA *ptr, PropertyRNA *prop, PointerRNA ptr
 {
        /*IDProperty *idprop;*/
 
+       BLI_assert(RNA_property_type(prop) == PROP_POINTER);
+
        if((/*idprop=*/ rna_idproperty_check(&prop, ptr))) {
                /* not supported */
        }
@@ -2029,6 +2266,9 @@ void RNA_property_pointer_set(PointerRNA *ptr, PropertyRNA *prop, PointerRNA ptr
 PointerRNA RNA_property_pointer_get_default(PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop))
 {
        //PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
+
+       // BLI_assert(RNA_property_type(prop) == PROP_POINTER);
+
        return PointerRNA_NULL; // FIXME: there has to be a way...
 }
 
@@ -2036,6 +2276,8 @@ void RNA_property_pointer_add(PointerRNA *ptr, PropertyRNA *prop)
 {
        /*IDProperty *idprop;*/
 
+       BLI_assert(RNA_property_type(prop) == PROP_POINTER);
+
        if((/*idprop=*/rna_idproperty_check(&prop, ptr))) {
                /* already exists */
        }
@@ -2057,6 +2299,8 @@ void RNA_property_pointer_remove(PointerRNA *ptr, PropertyRNA *prop)
 {
        IDProperty *idprop, *group;
 
+       BLI_assert(RNA_property_type(prop) == PROP_POINTER);
+
        if((idprop=rna_idproperty_check(&prop, ptr))) {
                group= RNA_struct_idprops(ptr, 0);
                
@@ -2083,6 +2327,8 @@ void RNA_property_collection_begin(PointerRNA *ptr, PropertyRNA *prop, Collectio
 {
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_COLLECTION);
+
        memset(iter, 0, sizeof(*iter));
 
        if((idprop=rna_idproperty_check(&prop, ptr)) || (prop->flag & PROP_IDPROPERTY)) {
@@ -2134,6 +2380,8 @@ int RNA_property_collection_length(PointerRNA *ptr, PropertyRNA *prop)
        CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_COLLECTION);
+
        if((idprop=rna_idproperty_check(&prop, ptr))) {
                return idprop->len;
        }
@@ -2158,6 +2406,8 @@ void RNA_property_collection_add(PointerRNA *ptr, PropertyRNA *prop, PointerRNA
        IDProperty *idprop;
 //     CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_COLLECTION);
+
        if((idprop=rna_idproperty_check(&prop, ptr))) {
                IDPropertyTemplate val = {0};
                IDProperty *item;
@@ -2215,6 +2465,8 @@ int RNA_property_collection_remove(PointerRNA *ptr, PropertyRNA *prop, int key)
        IDProperty *idprop;
 //     CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_COLLECTION);
+
        if((idprop=rna_idproperty_check(&prop, ptr))) {
                IDProperty tmp, *array;
                int len;
@@ -2260,6 +2512,8 @@ int RNA_property_collection_move(PointerRNA *ptr, PropertyRNA *prop, int key, in
 {
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_COLLECTION);
+
        if((idprop=rna_idproperty_check(&prop, ptr))) {
                IDProperty tmp, *array;
                int len;
@@ -2288,6 +2542,8 @@ void RNA_property_collection_clear(PointerRNA *ptr, PropertyRNA *prop)
 {
        IDProperty *idprop;
 
+       BLI_assert(RNA_property_type(prop) == PROP_COLLECTION);
+
        if((idprop=rna_idproperty_check(&prop, ptr)))
                IDP_ResizeIDPArray(idprop, 0);
 }
@@ -2297,6 +2553,8 @@ int RNA_property_collection_lookup_index(PointerRNA *ptr, PropertyRNA *prop, Poi
        CollectionPropertyIterator iter;
        int index= 0;
        
+       BLI_assert(RNA_property_type(prop) == PROP_COLLECTION);
+
        RNA_property_collection_begin(ptr, prop, &iter);
        for(index=0; iter.valid; RNA_property_collection_next(&iter), index++) {
                if (iter.ptr.data == t_ptr->data)
@@ -2315,6 +2573,8 @@ int RNA_property_collection_lookup_int(PointerRNA *ptr, PropertyRNA *prop, int k
 {
        CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)rna_ensure_property(prop);
 
+       BLI_assert(RNA_property_type(prop) == PROP_COLLECTION);
+
        if(cprop->lookupint) {
                /* we have a callback defined, use it */
                return cprop->lookupint(ptr, key, r_ptr);
@@ -2344,6 +2604,8 @@ int RNA_property_collection_lookup_string(PointerRNA *ptr, PropertyRNA *prop, co
 {
        CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)rna_ensure_property(prop);
 
+       BLI_assert(RNA_property_type(prop) == PROP_COLLECTION);
+
        if(cprop->lookupstring) {
                /* we have a callback defined, use it */
                return cprop->lookupstring(ptr, key, r_ptr);
@@ -2385,6 +2647,8 @@ int RNA_property_collection_lookup_string(PointerRNA *ptr, PropertyRNA *prop, co
 
 int RNA_property_collection_type_get(PointerRNA *ptr, PropertyRNA *prop, PointerRNA *r_ptr)
 {
+       BLI_assert(RNA_property_type(prop) == PROP_COLLECTION);
+
        *r_ptr= *ptr;
        return ((r_ptr->type = prop->srna) ? 1:0);
 }
@@ -2395,6 +2659,8 @@ int RNA_property_collection_raw_array(PointerRNA *ptr, PropertyRNA *prop, Proper
        ArrayIterator *internal;
        char *arrayp;
 
+       BLI_assert(RNA_property_type(prop) == PROP_COLLECTION);
+
        if(!(prop->flag & PROP_RAW_ARRAY) || !(itemprop->flag & PROP_RAW_ACCESS))
                return 0;
 
@@ -2460,7 +2726,7 @@ int RNA_raw_type_sizeof(RawPropertyType type)
        }
 }
 
-static int rna_raw_access(ReportList *reports, PointerRNA *ptr, PropertyRNA *prop, char *propname, void *inarray, RawPropertyType intype, int inlen, int set)
+static int rna_raw_access(ReportList *reports, PointerRNA *ptr, PropertyRNA *prop, const char *propname, void *inarray, RawPropertyType intype, int inlen, int set)
 {
        StructRNA *ptype;
        PointerRNA itemptr;
@@ -2762,12 +3028,12 @@ RawPropertyType RNA_property_raw_type(PropertyRNA *prop)
        return prop->rawtype;
 }
 
-int RNA_property_collection_raw_get(ReportList *reports, PointerRNA *ptr, PropertyRNA *prop, char *propname, void *array, RawPropertyType type, int len)
+int RNA_property_collection_raw_get(ReportList *reports, PointerRNA *ptr, PropertyRNA *prop, const char *propname, void *array, RawPropertyType type, int len)
 {
        return rna_raw_access(reports, ptr, prop, propname, array, type, len, 0);
 }
 
-int RNA_property_collection_raw_set(ReportList *reports, PointerRNA *ptr, PropertyRNA *prop, char *propname, void *array, RawPropertyType type, int len)
+int RNA_property_collection_raw_set(ReportList *reports, PointerRNA *ptr, PropertyRNA *prop, const char *propname, void *array, RawPropertyType type, int len)
 {
        return rna_raw_access(reports, ptr, prop, propname, array, type, len, 1);
 }
@@ -2922,7 +3188,7 @@ static char *rna_path_token(const char **path, char *fixedbuf, int fixedlen, int
                /* 2 kinds of lookups now, quoted or unquoted */
                quote= *p;
 
-               if(quote != '"')
+               if(quote != '"') /* " - this comment is hack for Aligorith's text editor's sanity */
                        quote= 0;
 
                if(quote==0) {
@@ -3203,7 +3469,7 @@ int RNA_path_resolve_full(PointerRNA *ptr, const char *path, PointerRNA *r_ptr,
 }
 
 
-char *RNA_path_append(const char *path, PointerRNA *ptr, PropertyRNA *prop, int intkey, const char *strkey)
+char *RNA_path_append(const char *path, PointerRNA *UNUSED(ptr), PropertyRNA *prop, int intkey, const char *strkey)
 {
        DynStr *dynstr;
        const char *s;
@@ -3241,7 +3507,7 @@ char *RNA_path_append(const char *path, PointerRNA *ptr, PropertyRNA *prop, int
                        BLI_dynstr_append(dynstr, "\"");
                }
                else {
-                       sprintf(appendstr, "%d", intkey);
+                       BLI_snprintf(appendstr, sizeof(appendstr), "%d", intkey);
                        BLI_dynstr_append(dynstr, appendstr);
                }
 
@@ -3423,12 +3689,19 @@ static char *rna_path_from_ID_to_idpgroup(PointerRNA *ptr)
        IDProperty *needle;
 
        BLI_assert(ptr->id.data != NULL);
+
+       /* TODO, Support Bones/PoseBones. no pointers stored to the bones from here, only the ID. See example in [#25746]
+        * unless this is added only way to find this is to also search all bones and pose bones of an armature or object */
        RNA_id_pointer_create(ptr->id.data, &id_ptr);
 
        haystack= RNA_struct_idprops(&id_ptr, FALSE);
-       needle= ptr->data;
-
-       return rna_idp_path(&id_ptr, haystack, needle, NULL);
+       if(haystack) { /* can fail when called on bones */
+               needle= ptr->data;
+               return rna_idp_path(&id_ptr, haystack, needle, NULL);
+       }
+       else {
+               return NULL;
+       }
 }
 
 char *RNA_path_from_ID_to_struct(PointerRNA *ptr)
@@ -3458,7 +3731,7 @@ char *RNA_path_from_ID_to_struct(PointerRNA *ptr)
                        else
                                return NULL; // can't do anything about this case yet...
                }
-               else if (RNA_struct_is_a(ptr->type, &RNA_IDPropertyGroup)) {
+               else if (RNA_struct_is_a(ptr->type, &RNA_PropertyGroup)) {
                        /* special case, easier to deal with here then in ptr->type->path() */
                        return rna_path_from_ID_to_idpgroup(ptr);
                }
@@ -3745,7 +4018,7 @@ char *RNA_string_get_alloc(PointerRNA *ptr, const char *name, char *fixedbuf, in
        }
        else {
                printf("RNA_string_get_alloc: %s.%s not found.\n", ptr->type->identifier, name);
-               return 0;
+               return NULL;
        }
 }
 
@@ -3874,8 +4147,9 @@ int RNA_property_is_idprop(PropertyRNA *prop)
 }
 
 /* string representation of a property, python
- * compatible but can be used for display too*/
-char *RNA_pointer_as_string(PointerRNA *ptr)
+ * compatible but can be used for display too,
+ * context may be NULL */
+char *RNA_pointer_as_string(bContext *C, PointerRNA *ptr)
 {
        DynStr *dynstr= BLI_dynstr_new();
        char *cstring;
@@ -3895,7 +4169,7 @@ char *RNA_pointer_as_string(PointerRNA *ptr)
                        BLI_dynstr_append(dynstr, ", ");
                first_time= 0;
                
-               cstring = RNA_property_as_string(NULL, ptr, prop);
+               cstring = RNA_property_as_string(C, ptr, prop);
                BLI_dynstr_appendf(dynstr, "\"%s\":%s", propname, cstring);
                MEM_freeN(cstring);
        }
@@ -4013,7 +4287,7 @@ char *RNA_property_as_string(bContext *C, PointerRNA *ptr, PropertyRNA *prop)
        case PROP_POINTER:
        {
                PointerRNA tptr= RNA_property_pointer_get(ptr, prop);
-               cstring= RNA_pointer_as_string(&tptr);
+               cstring= RNA_pointer_as_string(C, &tptr);
                BLI_dynstr_append(dynstr, cstring);
                MEM_freeN(cstring);
                break;
@@ -4032,7 +4306,7 @@ char *RNA_property_as_string(bContext *C, PointerRNA *ptr, PropertyRNA *prop)
                        first_time= 0;
                        
                        /* now get every prop of the collection */
-                       cstring= RNA_pointer_as_string(&itemptr);
+                       cstring= RNA_pointer_as_string(C, &itemptr);
                        BLI_dynstr_append(dynstr, cstring);
                        MEM_freeN(cstring);
                }
@@ -4073,12 +4347,12 @@ int RNA_function_defined(FunctionRNA *func)
        return func->call != NULL;
 }
 
-PropertyRNA *RNA_function_get_parameter(PointerRNA *ptr, FunctionRNA *func, int index)
+PropertyRNA *RNA_function_get_parameter(PointerRNA *UNUSED(ptr), FunctionRNA *func, int index)
 {
        return BLI_findlink(&func->cont.properties, index);
 }
 
-PropertyRNA *RNA_function_find_parameter(PointerRNA *ptr, FunctionRNA *func, const char *identifier)
+PropertyRNA *RNA_function_find_parameter(PointerRNA *UNUSED(ptr), FunctionRNA *func, const char *identifier)
 {
        return BLI_findstring(&func->cont.properties, identifier, offsetof(PropertyRNA, identifier));
 }
@@ -4090,7 +4364,7 @@ const struct ListBase *RNA_function_defined_parameters(FunctionRNA *func)
 
 /* Utility */
 
-ParameterList *RNA_parameter_list_create(ParameterList *parms, PointerRNA *ptr, FunctionRNA *func)
+ParameterList *RNA_parameter_list_create(ParameterList *parms, PointerRNA *UNUSED(ptr), FunctionRNA *func)
 {
        PropertyRNA *parm;
        void *data;
@@ -4228,7 +4502,7 @@ void RNA_parameter_list_next(ParameterIterator *iter)
        }
 }
 
-void RNA_parameter_list_end(ParameterIterator *iter)
+void RNA_parameter_list_end(ParameterIterator *UNUSED(iter))
 {
        /* nothing to do */
 }
@@ -4328,12 +4602,12 @@ void RNA_parameter_length_set(ParameterList *parms, PropertyRNA *parm, int lengt
        RNA_parameter_list_end(&iter);
 }
 
-int RNA_parameter_length_get_data(ParameterList *parms, PropertyRNA *parm, void *data)
+int RNA_parameter_length_get_data(ParameterList *UNUSED(parms), PropertyRNA *UNUSED(parm), void *data)
 {
        return *((int *)((char *)data));
 }
 
-void RNA_parameter_length_set_data(ParameterList *parms, PropertyRNA *parm, void *data, int length)
+void RNA_parameter_length_set_data(ParameterList *UNUSED(parms), PropertyRNA *UNUSED(parm), void *data, int length)
 {
        *((int *)data)= length;
 }
@@ -4931,3 +5205,19 @@ int RNA_property_copy(PointerRNA *ptr, PointerRNA *fromptr, PropertyRNA *prop, i
 
        return 0;
 }
+
+void RNA_warning(const char *format, ...)
+{
+       va_list args;
+
+       va_start(args, format);
+       vprintf(format, args);
+       va_end(args);
+
+#ifdef WITH_PYTHON
+       {
+               extern void PyC_LineSpit(void);
+               PyC_LineSpit();
+       }
+#endif
+}