Merge with trunk r37677
[blender.git] / source / blender / makesrna / intern / rna_access.c
index a89d52e..a632c5c 100644 (file)
@@ -288,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;
@@ -681,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;
@@ -743,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);
@@ -1084,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) {
@@ -1107,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;
 }
 
@@ -1287,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 */
 
@@ -1327,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);
@@ -1507,7 +1536,7 @@ 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;
 
@@ -1516,7 +1545,7 @@ int RNA_property_boolean_get_default(PointerRNA *ptr, PropertyRNA *prop)
        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;
        
@@ -1614,6 +1643,43 @@ 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];
@@ -1693,13 +1759,13 @@ 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;
        
@@ -1810,6 +1876,43 @@ 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];
@@ -1901,7 +2004,7 @@ 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;
 
@@ -1910,7 +2013,7 @@ float RNA_property_float_get_default(PointerRNA *ptr, PropertyRNA *prop)
        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;
        
@@ -2017,7 +2120,7 @@ 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;
 
@@ -2046,7 +2149,7 @@ 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;
 
@@ -2094,7 +2197,7 @@ 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;
 
@@ -2103,6 +2206,14 @@ int RNA_property_enum_get_default(PointerRNA *ptr, PropertyRNA *prop)
        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)
 {
@@ -3077,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) {
@@ -3358,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;
@@ -4236,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));
 }
@@ -4253,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;
@@ -4391,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 */
 }
@@ -4491,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;
 }