Merge with trunk r37677
[blender.git] / source / blender / makesrna / intern / rna_access.c
index cbd02d8..a632c5c 100644 (file)
 
 #include "rna_internal.h"
 
-void RNA_warning(const char *format, ...)
-{
-       va_list args;
-
-       va_start(args, format);
-       vprintf(format, args);
-       va_end(args);
-
-#if WITH_PYTHON
-       {
-               extern void PyC_LineSpit(void);
-               PyC_LineSpit();
-       }
-#endif
-}
-
 const PointerRNA PointerRNA_NULL= {{NULL}};
 
 /* Init/Exit */
@@ -304,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;
@@ -537,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;
@@ -679,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;
@@ -741,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);
@@ -782,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];
@@ -794,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;
                }
        }
@@ -919,10 +936,10 @@ void RNA_property_float_range(PointerRNA *ptr, PropertyRNA *prop, float *hardmin
                        IDProperty *item;
 
                        item= IDP_GetPropertyTypeFromGroup(idp_ui, "min", IDP_DOUBLE);
-                       *hardmin= item ? IDP_Double(item) : FLT_MIN; 
+                       *hardmin= item ? (float)IDP_Double(item) : FLT_MIN;
 
                        item= IDP_GetPropertyTypeFromGroup(idp_ui, "max", IDP_DOUBLE);
-                       *hardmax= item ? IDP_Double(item) : FLT_MAX;
+                       *hardmax= item ? (float)IDP_Double(item) : FLT_MAX;
 
                        return;
                }
@@ -950,16 +967,16 @@ void RNA_property_float_ui_range(PointerRNA *ptr, PropertyRNA *prop, float *soft
                        IDProperty *item;
 
                        item= IDP_GetPropertyTypeFromGroup(idp_ui, "soft_min", IDP_DOUBLE);
-                       *softmin= item ? IDP_Double(item) : FLT_MIN;
+                       *softmin= item ? (float)IDP_Double(item) : FLT_MIN;
 
                        item= IDP_GetPropertyTypeFromGroup(idp_ui, "soft_max", IDP_DOUBLE);
-                       *softmax= item ? IDP_Double(item) : FLT_MAX;
+                       *softmax= item ? (float)IDP_Double(item) : FLT_MAX;
 
                        item= IDP_GetPropertyTypeFromGroup(idp_ui, "step", IDP_DOUBLE);
-                       *step= item ? IDP_Double(item) : 1.0f;
+                       *step= item ? (float)IDP_Double(item) : 1.0f;
 
                        item= IDP_GetPropertyTypeFromGroup(idp_ui, "precision", IDP_DOUBLE);
-                       *precision= item ? IDP_Double(item) : 3.0f;
+                       *precision= item ? (float)IDP_Double(item) : 3.0f;
 
                        return;
                }
@@ -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;
@@ -4036,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;
@@ -4057,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);
        }
@@ -4175,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;
@@ -4194,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);
                }
@@ -4235,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));
 }
@@ -4252,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;
@@ -4390,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 */
 }
@@ -4490,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;
 }
@@ -5093,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
+}