private static object TryAddition(object currentValue, object value)
{
Type type = value.GetType();
Type type2 = currentValue.GetType();
MethodInfo methodInfo = null;
object obj2 = value;
MethodInfo[] methods = type2.GetMethods();
foreach (MethodInfo methodInfo2 in methods)
{
if (string.Compare(methodInfo2.Name, "op_Addition", StringComparison.Ordinal) == 0)
{
ParameterInfo[] parameters = methodInfo2.GetParameters();
Type parameterType = parameters[1].ParameterType;
if (parameters[0].ParameterType.IsAssignableFrom(type2))
{
if (!parameterType.IsAssignableFrom(type))
{
TypeConverter typeConverter = TypeConverterHelper.GetTypeConverter(parameterType);
if (!typeConverter.CanConvertFrom(type))
{
continue;
}
obj2 = TypeConverterHelper.DoConversionFrom(typeConverter, value);
}
if (methodInfo != null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "ChangePropertyActionAmbiguousAdditionOperationExceptionMessage", new object[1]
{
type2.Name
}));
}
methodInfo = methodInfo2;
}
}
}
if (methodInfo != null)
{
return(methodInfo.Invoke(null, new object[2]
{
currentValue,
obj2
}));
}
return(value);
}
private object IncrementCurrentValue(PropertyInfo propertyInfo)
{
if (!propertyInfo.CanRead)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "ChangePropertyActionCannotIncrementWriteOnlyPropertyExceptionMessage", new object[1]
{
propertyInfo.Name
}));
}
object value = propertyInfo.GetValue(base.Target, null);
object obj = value;
Type propertyType = propertyInfo.PropertyType;
TypeConverter typeConverter = TypeConverterHelper.GetTypeConverter(propertyInfo.PropertyType);
object obj2 = Value;
if (obj2 == null || value == null)
{
return(obj2);
}
if (typeConverter.CanConvertFrom(obj2.GetType()))
{
obj2 = TypeConverterHelper.DoConversionFrom(typeConverter, obj2);
}
if (typeof(double).IsAssignableFrom(propertyType))
{
return((double)value + (double)obj2);
}
if (typeof(int).IsAssignableFrom(propertyType))
{
return((int)value + (int)obj2);
}
if (typeof(float).IsAssignableFrom(propertyType))
{
return((float)value + (float)obj2);
}
if (typeof(string).IsAssignableFrom(propertyType))
{
return((string)value + (string)obj2);
}
return(TryAddition(value, obj2));
}
protected override void Invoke(object parameter)
{
if (base.AssociatedObject != null && !string.IsNullOrEmpty(PropertyName) && base.Target != null)
{
Type type = base.Target.GetType();
PropertyInfo property = type.GetProperty(PropertyName);
ValidateProperty(property);
object obj = Value;
TypeConverter typeConverter = TypeConverterHelper.GetTypeConverter(property.PropertyType);
Exception ex = null;
try
{
if (Value != null)
{
if (typeConverter != null && typeConverter.CanConvertFrom(Value.GetType()))
{
obj = typeConverter.ConvertFrom(Value);
}
else
{
typeConverter = TypeConverterHelper.GetTypeConverter(Value.GetType());
if (typeConverter != null && typeConverter.CanConvertTo(property.PropertyType))
{
obj = typeConverter.ConvertTo(Value, property.PropertyType);
}
}
}
if (Duration.HasTimeSpan)
{
ValidateAnimationPossible(type);
object currentPropertyValue = GetCurrentPropertyValue(base.Target, property);
AnimatePropertyChange(property, currentPropertyValue, obj);
}
else
{
if (Increment)
{
obj = IncrementCurrentValue(property);
}
property.SetValue(base.Target, obj, new object[0]);
}
}
catch (FormatException ex2)
{
ex = ex2;
}
catch (ArgumentException ex3)
{
ex = ex3;
}
catch (MethodAccessException ex4)
{
ex = ex4;
}
if (ex != null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "ChangePropertyActionCannotSetValueExceptionMessage", new object[3]
{
(Value != null) ? Value.GetType().Name : "null",
PropertyName,
property.PropertyType.Name
}), ex);
}
}
}
