public void SetValue(object value, bool isToSource, IValueConverter converter = null)
{
if (property == null)
{
Debug.LogError("SetValue property NULL");
return;
}
if (field != null)
{
var parentProp = property.GetValue(propertyOwner, null);
if (converter != null)
{
if (isToSource)
{
field.SetValue(parentProp, converter.ConvertBack(value, field.GetType(), null));
}
else
{
field.SetValue(parentProp, converter.Convert(value, field.GetType(), null));
}
}
else if (value is IConvertible)
{
field.SetValue(parentProp, Convert.ChangeType(value, field.FieldType));
}
else
{
field.SetValue(parentProp, value);
}
property.SetValue(propertyOwner, parentProp);
}
else
{
if (converter != null)
{
if (isToSource)
{
property.SetValue(propertyOwner, converter.ConvertBack(value, property.PropertyType, null));
}
else
{
property.SetValue(propertyOwner, converter.Convert(value, property.PropertyType, null));
}
}
else if (value is IConvertible)
{
property.SetValue(propertyOwner, Convert.ChangeType(value, property.PropertyType));
}
else
{
property.SetValue(propertyOwner, value, null);
}
}
}
public void UpdateSource()
{
if (!IsBound)
{
Debug.LogWarning("Unbound");
return;
}
var value = targetProperty.GetValue(target);
// use converter
if (converter != null)
{
value = converter.ConvertBack(value, sourceProperty.PropertyType);
}
try
{
// set value to source
sourceProperty.SetValue(source, value);
}
catch (Exception ex)
{
Debug.LogError(string.Format("Failed to set value to source. sourceType={0}, targetType={1}, exception={2}",
sourceProperty.PropertyType, targetProperty.PropertyType, ex.Message), target as UnityEngine.Object);
}
}
private void PushTargetToSourceCore(object state)
{
if (_changeLatch)
{
return;
}
//copy changes from target to source
var newValue = TargetPropertyExpression.NormalizedValue;
if (_converter != null)
{
newValue = _converter.ConvertBack(newValue, SourcePropertyExpression.PropertyType, _converterParameter, _converterCulture);
}
_changeLatch = true;
try
{
if (SourcePropertyExpression != null)
{
SourcePropertyExpression.Value = newValue;
}
}
finally
{
_changeLatch = false;
}
}
public void Convert_ConvertBackFuncIsNull_ReturnsDependencyPropertyUnsetValue()
{
Target = new TypedValueConverterBase <int, string>((value, parameter, culture) => string.Empty, null);
Target.ConvertBack("Valid string value", typeof(int), null, null)
.Should().Be(DependencyProperty.UnsetValue);
}
public object GetSettingValue(Type valueType)
{
object value = GetSettings()[SettingName];
if (value == null || value.GetType() == valueType)
{
return(value);
}
else if (ValueConverter != null)
{
return(ValueConverter.ConvertBack(value, valueType, null, new System.Globalization.CultureInfo("en-US")));
}
else
{
var converter = TypeDescriptor.GetConverter(valueType);
if (converter != null && converter.CanConvertFrom(value.GetType()))
{
return(converter.ConvertFrom(value));
}
else
{
return(null);
}
}
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
var val = value;
if (_converter != null)
{
val = _converter.ConvertBack(value, targetType, parameter, culture);
}
var changeGroup = _designItem.OpenGroup("Property: " + _propertyName);
try
{
var property = _designItem.Properties.GetProperty(_propertyName);
property.SetValue(val);
if (!_singleItemProperty && _designItem.Services.Selection.SelectedItems.Count > 1)
{
var msg = MessageBoxResult.Yes;
if (_askWhenMultipleItemsSelected)
{
msg = MessageBox.Show("Apply changes to all selected Items", "", MessageBoxButton.YesNo);
}
if (msg == MessageBoxResult.Yes)
{
foreach (var item in _designItem.Services.Selection.SelectedItems)
{
try
{
if (_property != null)
{
property = item.Properties.GetProperty(_property);
}
else
{
property = item.Properties.GetProperty(_propertyName);
}
}
catch (Exception)
{ }
if (property != null)
{
property.SetValue(val);
}
}
}
}
changeGroup.Commit();
}
catch (Exception)
{
changeGroup.Abort();
}
return(val);
}
/// <summary>
/// Converts the binding using the specified <paramref name="converter"/> object.
/// </summary>
/// <returns>A new binding that will be converted using the specified IValueConverter.</returns>
/// <param name="converter">Converter object to use when converting to/from the value</param>
/// <param name="propertyType">Type for the converter to convert to</param>
/// <param name="conveterParameter">Parameter to pass to the converter.</param>
/// <param name="culture">Culture to use for conversion, null to use invariant culture.</param>
public IndirectBinding <object> Convert(IValueConverter converter, Type propertyType, object conveterParameter = null, CultureInfo culture = null)
{
culture = culture ?? CultureInfo.InvariantCulture;
return(Convert(
val => converter.Convert(val, propertyType, conveterParameter, culture),
val => (T)converter.ConvertBack(val, typeof(T), conveterParameter, culture)
));
}
protected bool ConvertBack(object val, Type targetType, out object result)
{
if (_valueConverter != null)
{
return(_valueConverter.ConvertBack(val, targetType, _converterParameter, ServiceRegistration.Get <ILocalization>().CurrentCulture, out result));
}
return(TypeConverter.Convert(val, targetType, out result));
}
protected override object CoerceBeforeConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
{
if (externalConverter != null)
{
return(externalConverter.ConvertBack(value, backConversionType, parameter, culture));
}
return(base.CoerceBeforeConvertBack(value, targetTypes, parameter, culture));
}
public void ConvertBack_ConvertBackFuncReturnsIntFor42String_ReturnsEqualValue()
{
const int expectedValue = 42;
Target = new TypedValueConverterBase <int, string>((i, o, c) => string.Empty, (s, o, c) => expectedValue);
Target.ConvertBack("42", typeof(int), null, null)
.Should().Be(expectedValue);
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
if (multiValueConverter != null)
{
value = multiValueConverter.ConvertBack(value, targetType, parameter, culture);
}
return(value);
}
protected override object CoerceBeforeConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
{
if (externalConverter != null)
{
var t = targetTypes != null && targetTypes.Count() == 1 ? targetTypes[0] : backConversionType;
return(externalConverter.ConvertBack(value, t, parameter, culture));
}
return(base.CoerceBeforeConvertBack(value, targetTypes, parameter, culture));
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
if (converter != null)
{
return(converter.ConvertBack(value, targetType, parameter, culture));
}
return(Binding.DoNothing);
}
private static void VerifyConvert(IValueConverter converter, string input, double?expected)
{
var value = (double?)converter.ConvertBack(input, null, null, null);
value.Should().Be(expected);
var text = (string)converter.Convert(value, null, null, null);
text.Should().Be(input);
}
private static void OnNetworkTableChange(ITable table, string key, Value v, NotifyFlags flags)
{
try
{
//multiple objects could be bound to this key
foreach (INotifyPropertyChanged source in propertyLookup.Keys)
{
OneToOneConversionMap <string, string> conversionMap = propertyLookup[source];
ITable boundTable = customTables[source];
object bindingSource = (source is DependencyNotifyListener) ? (object)(source as DependencyNotifyListener).source : source;
if (table.ToString() != boundTable.ToString())
{
continue;
}
if (conversionMap.TryGetBySecond(key, out string property))
{
//the property that changed is bound to this object
//grab the converter and use it if needed
IValueConverter converter = conversionMap.GetConverterByFirst(property);
PropertyInfo inf = bindingSource.GetType().GetProperty(property);
//issue using v for some reason
object value = NetworkUtil.ReadValue(boundTable.GetValue(key, null));
if (converter != null)
{
//in an NTConverter (required in API) the null values are never used so we don't need to set them
object attemptedVal = converter.ConvertBack(value, null, null, null);
//in case the conversion was invalid
if (attemptedVal != DependencyProperty.UnsetValue)
{
value = attemptedVal;
}
}
//correct any type inconsistencies (eg if we want to display an integer from the network, which only stores doubles)
if (value != null && value.GetType() != inf.PropertyType)
{
Type targetType = inf.PropertyType;
if (targetType.IsGenericType && targetType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
targetType = targetType.GetGenericArguments()[0];
}
//anything still here can make an invalid cast to let them know to use a converter
value = Convert.ChangeType(value, targetType);
}
//write to the object
assignmentDispatch.Invoke(() => inf.SetValue(bindingSource, value));
}
}
}
catch (InvalidOperationException e)
{
if (!e.Message.StartsWith("Collection was modified"))
{
throw e;
}
}
}
void PerformTwoWayConverterTest(IValueConverter converter, object input, object expectedValue, object parameter)
{
var culture = CultureInfo.CurrentUICulture;
var convertedValue = converter.Convert(input, null, parameter, culture);
var convertBackValue = converter.ConvertBack(expectedValue, null, parameter, culture);
Assert.AreEqual(expectedValue, convertedValue);
Assert.AreEqual(input, convertBackValue);
}
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, System.Globalization.CultureInfo culture)
{
if (_lastConverter == null)
{
return new object[] { value }
}
;
return(new object[] { _lastConverter.ConvertBack(value, targetTypes[0], _lastParameter, culture) });
}
}
public void ValueChangeCheck(string s)
{
System.Object res = s;
if (vc != null)
{
res = vc.ConvertBack(res, res.GetType(), null, null);
}
this.obj.GetType().GetProperty(this.path).SetValue(this.obj, res);
}
/// <summary>
/// Binds column to <see cref="TextBox"/> with specified value converter and culture info.
/// </summary>
/// <param name="source">The source column.</param>
/// <param name="converter">The value converter.</param>
/// <param name="cultureInfo">The culture info.</param>
/// <param name="flushErrorMessage">The conversion error message when flushing data from binding to source model.</param>
/// <returns>The row binding object.</returns>
public static RowBinding <TextBox> BindToTextBox(this Column source, IValueConverter converter, CultureInfo cultureInfo, string flushErrorMessage = null)
{
source.VerifyNotNull(nameof(source));
converter.VerifyNotNull(nameof(converter));
cultureInfo.VerifyNotNull(nameof(cultureInfo));
return(new RowBinding <TextBox>(onSetup: (v, p) => v.Setup(), onCleanup: (v, p) => v.Cleanup(), onRefresh: (v, p) =>
{
if (!v.GetIsEditing())
{
v.Text = Convert(p[source], converter, cultureInfo);
}
}).BeginInput(TextBox.TextProperty, TextBox.LostFocusEvent)
.WithFlushingValidator(v =>
{
try
{
var result = converter.ConvertBack(v.Text, source.DataType, null, cultureInfo);
if (result == DependencyProperty.UnsetValue)
{
return GetInvalidInputErrorMessage(flushErrorMessage, source.DataType);
}
}
catch (Exception ex)
{
return ex.Message;
}
return null;
})
.WithFlush(source, (p, v) =>
{
var value = converter.ConvertBack(v.Text, source.DataType, null, cultureInfo);
var oldValue = p[source];
if (Equals(oldValue, value))
{
return false;
}
p[source] = value;
return true;
})
.EndInput());
}
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
{
if (Converter == null)
{
return new object[] { value }
}
; // Required for VS design-time
return(new object[] { Converter.ConvertBack(value, targetTypes[0], lastParameter, culture) });
}
}
public void DstUpdated()
{
if (_converter != null)
{
_src.SetValue(_converter.ConvertBack(_dst.GetValue(), _src.property.PropertyType, null));
}
else
{
_src.SetValue(Convert.ChangeType(_dst.GetValue(), _src.property.PropertyType));
}
}
public void IdenticalThroughConversionCycle()
{
for (int i = 0; i < 31; i++)
{
Rgb15 initial = new(i, 0, 0);
Color midpoint = (Color)_converter.Convert(initial, typeof(Color), null, null);
Rgb15 final = (Rgb15)_converter.ConvertBack(midpoint, typeof(Rgb15), null, null);
final.Should().Be(initial);
}
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
if (converter != null)
{
return(converter.ConvertBack(value, targetType, parameter, culture));
}
else
{
throw new NotSupportedException();
}
}
protected override void OnParse(ConvertEventArgs cevent)
{
if (_converter != null)
{
cevent.Value = _converter.ConvertBack(cevent.Value,
cevent.DesiredType, _converterParameter, _converterCulture);
}
else
{
base.OnParse(cevent);
}
}
protected override void OnParse(ConvertEventArgs cevent)
{
if (_converter == null)
{
base.OnParse(cevent);
}
else
{
object valueFromCtl = _converter.ConvertBack(cevent.Value, cevent.DesiredType, _converterParameter, _converterCulture);
cevent.Value = valueFromCtl;
}
}
public void ConvertBack_ValueIsNotTargetType_ThrowsArgumentException()
{
Target = new TypedValueConverterBase <int, string>((i, o, c) => string.Empty, (s, o, c) => 0);
var convertBack = new Action(() => Target.ConvertBack(
42, //Not target type (string)
typeof(int), null, null));
convertBack.ShouldThrow <ArgumentException>()
.WithMessage("Value must be of type " + typeof(string) + "*")
.And.ParamName.Should().Be("value");
}
private static void VerifyConvert(object?source)
{
var expected = _reference.Convert(source, null, null, null);
var result = _target.Convert(source, null, null, null);
Assert.AreEqual(expected, result);
expected = _reference.ConvertBack(source, null, null, null);
result = _target.ConvertBack(source, null, null, null);
Assert.AreEqual(expected, result);
}
public void ConvertBack_TargetTypeIsNotConverterSourceType_ThrowsArgumentException()
{
Target = new TypedValueConverterBase <int, string>((i, o, c) => string.Empty, (s, o, c) => 0);
var convert = new Action(() => Target.ConvertBack("A valid string value",
typeof(bool), //Not source type of converter
null, null));
convert.ShouldThrow <ArgumentException>()
.WithMessage("TargetType must be " + typeof(int) + "*")
.And.ParamName.Should().Be("targetType");
}
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, System.Globalization.CultureInfo culture)
{
if (_chainedConverter != null)
{
try { value = _chainedConverter.ConvertBack(value, typeof(object), parameter, culture); }
catch (Exception e)
{
EquationTokenizer.ThrowQuickConverterEvent(new ChainedConverterExceptionEventArgs(ConvertExpression, value, typeof(object), parameter, culture, true, _chainedConverter, this, e));
return(new object[targetTypes.Length].Select(o => value).ToArray());
}
if (value == DependencyProperty.UnsetValue || value == System.Windows.Data.Binding.DoNothing)
{
return(new object[targetTypes.Length].Select(o => value).ToArray());
}
}
object[] ret = new object[_convertBack.Length];
if (ValueType != null && !ValueType.IsInstanceOfType(value))
{
for (int i = 0; i < ret.Length; ++i)
{
ret[i] = System.Windows.Data.Binding.DoNothing;
}
return(ret);
}
for (int i = 0; i < _convertBack.Length; ++i)
{
try { ret[i] = _convertBack[i](value, _values); }
catch (Exception e)
{
LastException = e;
++ExceptionCount;
if (Debugger.IsAttached)
{
Console.WriteLine("QuickMultiConverter Exception (\"" + ConvertBackExpression[i] + "\") - " + e.Message + (e.InnerException != null ? " (Inner - " + e.InnerException.Message + ")" : ""));
}
EquationTokenizer.ThrowQuickConverterEvent(new RuntimeMultiConvertExceptionEventArgs(ConvertBackExpression[i], ConvertBackExpressionDebugView[i], null, _pIndices, value, _values, parameter, this, e));
ret[i] = DependencyProperty.UnsetValue;
}
ret[i] = CastResult(ret[i], targetTypes[i]);
}
if (_fromDataContainers != null)
{
foreach (var container in _fromDataContainers)
{
container.Value = null;
}
}
return(ret);
}
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
{
if (lastConverter == null)
{
return new object[] { value }
}
;
return(new object[] { lastConverter.ConvertBack(value, targetTypes[0], lastParameter, culture) });
}
#endregion IMultiValueConverter Members
}
public void ConvertBackWithNullParameter_ShouldThrowArgumentNullException(IValueConverter converter)
{
try
{
result = converter.ConvertBack(null, null, null, "");
Assert.Fail("An exception should have been thrown");
}
catch (ArgumentNullException exception)
{
StringAssert.Contains(exception.Message, "");
}
catch (Exception e)
{
Assert.Fail("The wrong exception has been thrown");
}
}
/// <summary>
/// Checks to see if a given value matches a property's original value,
/// and updates the ability to commit the edit if not.
/// </summary>
/// <param name="propertyName">The name of the property to check against.</param>
/// <param name="value">The value to check against.</param>
/// <param name="doConversion">Whether or not to convert the value to the original type.</param>
/// <param name="originalType">The original type.</param>
/// <param name="valueConverter">The IValueConverter to use for conversion.</param>
/// <param name="converterParameter">The converter parameter.</param>
/// <param name="converterCulture">The converter culture.</param>
private void CheckIfPropertyEditedAndUpdate(
string propertyName,
object value,
bool doConversion,
Type originalType,
IValueConverter valueConverter,
object converterParameter,
CultureInfo converterCulture)
{
object originalValue;
if (!this._editablePropertiesOriginalValues.TryGetValue(propertyName, out originalValue))
{
return;
}
if (doConversion && value != null)
{
// Attempt to convert the value provided to the type of the original type.
// If the conversion fails, just keep it as is.
try
{
if (valueConverter != null)
{
value = valueConverter.ConvertBack(value, originalType, converterParameter, converterCulture);
}
else
{
value = Convert.ChangeType(value, originalType, converterCulture);
}
}
catch (InvalidCastException)
{
}
catch (FormatException)
{
}
catch (OverflowException)
{
}
}
bool valueEqualsOriginal =
(value == null && originalValue == null) ||
(value != null && originalValue != null && value.Equals(originalValue));
if (valueEqualsOriginal &&
this._editedProperties.Contains(propertyName))
{
this._editedProperties.Remove(propertyName);
SetAllCanPropertiesAndUpdate(this, false /* onlyUpdateStates */);
}
else if (!valueEqualsOriginal &&
!this._editedProperties.Contains(propertyName))
{
this._editedProperties.Add(propertyName);
SetAllCanPropertiesAndUpdate(this, false /* onlyUpdateStates */);
}
}
private object ConvertBackHelper(IValueConverter converter,
object value,
Type sourceType,
object parameter,
CultureInfo culture)
{
Invariant.Assert(converter != null);
// PreSharp uses message numbers that the C# compiler doesn't know about.
// Disable the C# complaints, per the PreSharp documentation.
#pragma warning disable 1634, 1691
// PreSharp complains about catching NullReference (and other) exceptions.
// It doesn't recognize that IsCritical[Application]Exception() handles these correctly.
#pragma warning disable 56500
object convertedValue = null;
try
{
convertedValue = converter.ConvertBack(value, sourceType, parameter, culture);
}
// Catch all exceptions. There is no app code on the stack,
// so the exception isn't actionable by the app.
// Yet we don't want to crash the app.
catch (Exception ex)
{
// the DefaultValueConverter can end up calling BaseUriHelper.GetBaseUri()
// which can raise SecurityException if the app does not have the right FileIO privileges
ex = CriticalExceptions.Unwrap(ex);
if (CriticalExceptions.IsCriticalApplicationException(ex))
throw;
if (TraceData.IsEnabled)
{
TraceData.Trace(TraceEventType.Error,
TraceData.BadConverterForUpdate(
AvTrace.ToStringHelper(Value),
AvTrace.TypeName(value)),
this, ex);
}
ProcessException(ex, ValidatesOnExceptions);
convertedValue = DependencyProperty.UnsetValue;
}
catch // non CLS compliant exception
{
if (TraceData.IsEnabled)
{
TraceData.Trace(TraceEventType.Error,
TraceData.BadConverterForUpdate(
AvTrace.ToStringHelper(Value),
AvTrace.TypeName(value)),
this);
}
convertedValue = DependencyProperty.UnsetValue;
}
#pragma warning restore 56500
#pragma warning restore 1634, 1691
return convertedValue;
}
