protected override bool SetValueInternal(object value, ValueUpdateSource updateSource)
{
bool result = false;
#if _DOTNET2
NullableConverter nc = TypeConverter as NullableConverter;
if ((value == null) || ((value != null) && UnderlyingType.IsInstanceOfType(value)) ||
((nc != null) && ((value == null) || nc.UnderlyingType.IsInstanceOfType(value))))
#else
if ((value != null) && UnderlyingType.IsInstanceOfType(value))
#endif
{
UnderlyingValue = value;
result = true;
}
if (updateSource != ValueUpdateSource.FromChild)
{
if ((mOwnerEnumerator != null) && // mOwnerEnumerator could be null for the boolean of Property._enabledVariable
!mOwnerEnumerator.Property.Value.NoLinkWithChildren)
{
PropertyTypeDescriptorContext context = GetTypeDescriptorContext(OwnerEnumerator);
if (TypeConverter.GetPropertiesSupported(context) == false)
{
PropertyEnumerator childEnum = mOwnerEnumerator.Children;
if (childEnum.Count > 0)
{
string masterStr = mOwnerEnumerator.Property.Value.GetStringValue();
char separator = mOwnerEnumerator.Property.Value.GroupedValueSeparator;
while (childEnum != childEnum.RightBound)
{
masterStr.TrimStart(null);
int count = masterStr.IndexOf(separator);
if (count != -1)
{
childEnum.Property.Value.SetValue(masterStr.Substring(0, count));
if (count + 2 < masterStr.Length)
{
masterStr = masterStr.Substring(count + 2); // advance after the separator and the leading space
}
}
else
{
childEnum.Property.Value.SetValue(masterStr);
break;
}
childEnum.MoveNext();
}
}
}
}
}
return(result);
}
protected override bool SetValueInternal(object value, ValueUpdateSource updateSource)
{
bool result;
// Update the new value of this property
if (value is string)
{
if (UnderlyingType.IsEnum)
{
object enumValue = TypeConverter.ConvertFromString(GetTypeDescriptorContext(OwnerEnumerator),
CultureInfo, GetActualString(value as string));
// If the enum is flagged, we don't test if the value to be assigned is correct
if (UnderlyingType.IsDefined(typeof(FlagsAttribute), false))
{
result = SetMultipleValues(enumValue);
}
else
{
if (Enum.IsDefined(UnderlyingType, enumValue))
{
result = SetMultipleValues(enumValue);
}
else
{
result = false;
}
}
}
else
{
PropertyTypeDescriptorContext context = GetTypeDescriptorContext(OwnerEnumerator);
string str = GetActualString(value as string);
if (TypeConverter.CanConvertFrom(context, typeof(string)))
{
result = SetMultipleValues(TypeConverter.ConvertFromString(
context, CultureInfo, str));
}
else
{
result = SetMultipleValues(str);
}
}
}
else
{
result = SetMultipleValues(value);
}
return(result);
}
protected override bool SetValueInternal(object value, ValueUpdateSource updateSource)
{
try
{
PropertyValue parentValue = mOwnerEnumerator.Parent.Property.Value;
TypeConverter converter = parentValue.TypeConverter;
PropertyTypeDescriptorContext context = GetTypeDescriptorContext(OwnerEnumerator);
PropertyDescriptorCollection collection = converter.GetProperties(context, parentValue.GetValue());
if (collection != null)
{
IDictionary dictionary = new Hashtable(collection.Count);
foreach (PropertyDescriptor propertyDescriptor in collection)
{
if (OwnerEnumerator.Property.Name.Equals(propertyDescriptor.Name))
{
if (value is string)
{
dictionary[propertyDescriptor.Name] = TypeConverter.ConvertFromString(
context, CultureInfo, GetActualString(value as string));
}
else
{
dictionary[propertyDescriptor.Name] = value;
}
}
else
{
dictionary[propertyDescriptor.Name] = propertyDescriptor.GetValue(TargetInstance);
}
}
// Create the parent value from all the sibling values
PropertyDescriptor.SetValue(TargetInstance, value);
parentValue.SetValue(converter.CreateInstance(context, dictionary), ValueUpdateSource.FromChild);
}
}
catch (Exception)
{
return(false);
}
return(true);
}
protected override bool SetValueInternal(object value, ValueUpdateSource updateSource)
{
try
{
PropertyValue parentValue = mOwnerEnumerator.Parent.Property.Value;
TypeConverter converter = parentValue.TypeConverter;
PropertyTypeDescriptorContext context = GetTypeDescriptorContext(OwnerEnumerator);
PropertyDescriptorCollection collection = converter.GetProperties(context, parentValue.GetValue());
if (collection != null)
{
IDictionary dictionary = new Hashtable(collection.Count);
foreach (PropertyDescriptor propertyDescriptor in collection)
{
if (OwnerEnumerator.Property.Name.Equals(propertyDescriptor.Name))
{
if (value is string)
{
dictionary[propertyDescriptor.Name] = TypeConverter.ConvertFromString(
context, CultureInfo, GetActualString(value as string));
}
else
dictionary[propertyDescriptor.Name] = value;
}
else
dictionary[propertyDescriptor.Name] = propertyDescriptor.GetValue(TargetInstance);
}
// Create the parent value from all the sibling values
PropertyDescriptor.SetValue(TargetInstance, value);
parentValue.SetValue(converter.CreateInstance(context, dictionary), ValueUpdateSource.FromChild);
}
}
catch (Exception)
{
return false;
}
return true;
}
/// <summary>
/// Modifies the content of the underlying value.
/// </summary>
/// <param name="value">The object from which content must be assigned to the underlying value.</param>
/// <param name="updateSource"></param>
/// <returns>A boolean is the underlying value was successfully changed, false otherwise.</returns>
protected virtual bool SetValueInternal(object value, ValueUpdateSource updateSource)
{
return false;
}
protected internal ValueValidationResult SetValue(object value, ValueUpdateSource updateSource)
{
bool result;
try
{
result = SetValueInternal(value, updateSource);
}
catch (Exception e)
{
_lastExceptionByClient = e;
return ValueValidationResult.ExceptionByClient;
}
if (result && (mOwnerEnumerator != null)) // mOwnerEnumerator could be null for the boolean of Property._enabledVariable
{
// RecreateChildProperties();
// Inform its parent that this value has changed
if (updateSource != ValueUpdateSource.FromParent)
{
if ((mOwnerEnumerator.Parent.Property != null) && (mOwnerEnumerator.Parent.Property.Value != null) &&
(mOwnerEnumerator.Parent.Property.Value.NoLinkWithChildren == false))
mOwnerEnumerator.Parent.Property.Value.OnChildValueChanged(this);
}
if ((mOwnerEnumerator.Children.Count > 0) && (updateSource != ValueUpdateSource.FromChild) &&
(NoLinkWithChildren == false))
{
// Inform its children that this value has changed
PropertyEnumerator childEnum = mOwnerEnumerator.Children;
while (childEnum != childEnum.RightBound)
{
if (childEnum.Property.Value != null)
childEnum.Property.Value.OnParentValueChanged(this);
childEnum.MoveNext();
}
ReUpdateFromChildren();
}
Control inplaceCtrl = mOwnerEnumerator.Property.ParentGrid.InPlaceControl;
IInPlaceControl iinplaceCtrl = inplaceCtrl as IInPlaceControl;
if ((iinplaceCtrl != null) && !_setValueFromInPlaceCtrl && (iinplaceCtrl.OwnerPropertyEnumerator == mOwnerEnumerator))
// If there is an inplace control for this value, then update its content
iinplaceCtrl.OwnerPropertyEnumerator = mOwnerEnumerator;
else
// Else just redraw the grid
mOwnerEnumerator.Property.ParentGrid.Grid.Invalidate();
}
return (result ? ValueValidationResult.Validated : ValueValidationResult.TypeConverterFailed);
}
protected override bool SetValueInternal(object value, ValueUpdateSource updateSource)
{
bool result = false;
#if _DOTNET2
NullableConverter nc = TypeConverter as NullableConverter;
if ((value == null) || ((value != null) && UnderlyingType.IsInstanceOfType(value)) ||
((nc != null) && ((value == null) || nc.UnderlyingType.IsInstanceOfType(value))))
#else
if ((value != null) && UnderlyingType.IsInstanceOfType(value))
#endif
{
UnderlyingValue = value;
result = true;
}
if (updateSource != ValueUpdateSource.FromChild)
{
if ((mOwnerEnumerator != null) && // mOwnerEnumerator could be null for the boolean of Property._enabledVariable
!mOwnerEnumerator.Property.Value.NoLinkWithChildren)
{
PropertyTypeDescriptorContext context = GetTypeDescriptorContext(OwnerEnumerator);
if (TypeConverter.GetPropertiesSupported(context) == false)
{
PropertyEnumerator childEnum = mOwnerEnumerator.Children;
if (childEnum.Count > 0)
{
string masterStr = mOwnerEnumerator.Property.Value.GetStringValue();
char separator = mOwnerEnumerator.Property.Value.GroupedValueSeparator;
while (childEnum != childEnum.RightBound)
{
masterStr.TrimStart(null);
int count = masterStr.IndexOf(separator);
if (count != -1)
{
childEnum.Property.Value.SetValue(masterStr.Substring(0, count));
if (count + 2 < masterStr.Length)
masterStr = masterStr.Substring(count + 2); // advance after the separator and the leading space
}
else
{
childEnum.Property.Value.SetValue(masterStr);
break;
}
childEnum.MoveNext();
}
}
}
}
}
return result;
}
protected override bool SetValueInternal(object value, ValueUpdateSource updateSource)
{
bool result = true;
// If the user tries to set the value as a string
if ((value != null) && (value.GetType() == typeof(string)))
{
if (UnderlyingType == typeof(string))
{
try
{
// We set the value directly to the underlying data (to its C# Field or Property)
if (_memberInfo.MemberType == MemberTypes.Property)
((PropertyInfo)_memberInfo).GetSetMethod(true).Invoke(_targetInstance, new object[] { value });
else
((FieldInfo)_memberInfo).SetValue(_targetInstance, value);
}
catch (ArgumentException)
{
result = false;
}
}
else
{
try
{
string newString = GetActualString(value as string);
if (newString != null)
{
if (_memberInfo.MemberType == MemberTypes.Property)
((PropertyInfo)_memberInfo).GetSetMethod(true).Invoke(_targetInstance, new object[] {
TypeConverter.ConvertFromString(GetTypeDescriptorContext(OwnerEnumerator),
CultureInfo, newString) });
else
((FieldInfo)_memberInfo).SetValue(_targetInstance, TypeConverter.ConvertFromString(
GetTypeDescriptorContext(OwnerEnumerator), CultureInfo, newString));
}
else
{
if (_memberInfo.MemberType == MemberTypes.Property)
((PropertyInfo)_memberInfo).GetSetMethod(true).Invoke(_targetInstance, new object[] {
TypeConverter.ConvertFromString(GetTypeDescriptorContext(OwnerEnumerator),
CultureInfo, value as string) });
else
((FieldInfo)_memberInfo).SetValue(_targetInstance, TypeConverter.ConvertFromString(
GetTypeDescriptorContext(OwnerEnumerator), CultureInfo, value as string));
}
}
catch (Exception)
{
result = false;
}
}
}
// Else if the user doesn't try to set the value as a string
else
{
try
{
// We set the value directly to the underlying data (to its C# Field or Property)
if (_memberInfo.MemberType == MemberTypes.Property)
((PropertyInfo)_memberInfo).GetSetMethod(true).Invoke(_targetInstance, new object[] { value });
else
((FieldInfo)_memberInfo).SetValue(_targetInstance, value);
}
catch (ArgumentException)
{
result = false;
}
}
if (updateSource != ValueUpdateSource.FromChild)
{
if (mOwnerEnumerator != null) // mOwnerEnumerator could be null for the boolean of Property._enabledVariable
{
PropertyEnumerator childEnum = mOwnerEnumerator.Children;
if (childEnum.Count > 0)
{
string masterStr = mOwnerEnumerator.Property.Value.GetStringValue();
char separator = mOwnerEnumerator.Property.Value.GroupedValueSeparator;
while (childEnum != childEnum.RightBound)
{
masterStr.TrimStart(null);
int count = masterStr.IndexOf(separator);
if (count != -1)
{
childEnum.Property.Value.SetValue(masterStr.Substring(0, count));
if (count + 2 < masterStr.Length)
masterStr = masterStr.Substring(count + 2); // advance after the separator and the leading space
}
else
{
childEnum.Property.Value.SetValue(masterStr);
break;
}
childEnum.MoveNext();
}
}
}
}
return result;
}
protected override bool SetValueInternal(object value, ValueUpdateSource updateSource)
{
bool result;
// Update the new value of this property
if (value is string)
{
if (UnderlyingType.IsEnum)
{
object enumValue = TypeConverter.ConvertFromString(GetTypeDescriptorContext(OwnerEnumerator),
CultureInfo, GetActualString(value as string));
// If the enum is flagged, we don't test if the value to be assigned is correct
if (UnderlyingType.IsDefined(typeof(FlagsAttribute), false))
result = SetMultipleValues(enumValue);
else
{
if (Enum.IsDefined(UnderlyingType, enumValue))
result = SetMultipleValues(enumValue);
else
result = false;
}
}
else
{
PropertyTypeDescriptorContext context = GetTypeDescriptorContext(OwnerEnumerator);
string str = GetActualString(value as string);
if (TypeConverter.CanConvertFrom(context, typeof(string)))
{
result = SetMultipleValues(TypeConverter.ConvertFromString(
context, CultureInfo, str));
}
else
{
result = SetMultipleValues(str);
}
}
}
else
result = SetMultipleValues(value);
return result;
}
protected override bool SetValueInternal(object value, ValueUpdateSource updateSource)
{
bool result = true;
// If the user tries to set the value as a string
if ((value != null) && (value.GetType() == typeof(string)))
{
if (UnderlyingType == typeof(string))
{
try
{
// We set the value directly to the underlying data (to its C# Field or Property)
if (_memberInfo.MemberType == MemberTypes.Property)
{
((PropertyInfo)_memberInfo).GetSetMethod(true).Invoke(_targetInstance, new object[] { value });
}
else
{
((FieldInfo)_memberInfo).SetValue(_targetInstance, value);
}
}
catch (ArgumentException)
{
result = false;
}
}
else
{
try
{
string newString = GetActualString(value as string);
if (newString != null)
{
if (_memberInfo.MemberType == MemberTypes.Property)
{
((PropertyInfo)_memberInfo).GetSetMethod(true).Invoke(_targetInstance, new object[] {
TypeConverter.ConvertFromString(GetTypeDescriptorContext(OwnerEnumerator),
CultureInfo, newString)
});
}
else
{
((FieldInfo)_memberInfo).SetValue(_targetInstance, TypeConverter.ConvertFromString(
GetTypeDescriptorContext(OwnerEnumerator), CultureInfo, newString));
}
}
else
{
if (_memberInfo.MemberType == MemberTypes.Property)
{
((PropertyInfo)_memberInfo).GetSetMethod(true).Invoke(_targetInstance, new object[] {
TypeConverter.ConvertFromString(GetTypeDescriptorContext(OwnerEnumerator),
CultureInfo, value as string)
});
}
else
{
((FieldInfo)_memberInfo).SetValue(_targetInstance, TypeConverter.ConvertFromString(
GetTypeDescriptorContext(OwnerEnumerator), CultureInfo, value as string));
}
}
}
catch (Exception)
{
result = false;
}
}
}
// Else if the user doesn't try to set the value as a string
else
{
try
{
// We set the value directly to the underlying data (to its C# Field or Property)
if (_memberInfo.MemberType == MemberTypes.Property)
{
((PropertyInfo)_memberInfo).GetSetMethod(true).Invoke(_targetInstance, new object[] { value });
}
else
{
((FieldInfo)_memberInfo).SetValue(_targetInstance, value);
}
}
catch (ArgumentException)
{
result = false;
}
}
if (updateSource != ValueUpdateSource.FromChild)
{
if (mOwnerEnumerator != null) // mOwnerEnumerator could be null for the boolean of Property._enabledVariable
{
PropertyEnumerator childEnum = mOwnerEnumerator.Children;
if (childEnum.Count > 0)
{
string masterStr = mOwnerEnumerator.Property.Value.GetStringValue();
char separator = mOwnerEnumerator.Property.Value.GroupedValueSeparator;
while (childEnum != childEnum.RightBound)
{
masterStr.TrimStart(null);
int count = masterStr.IndexOf(separator);
if (count != -1)
{
childEnum.Property.Value.SetValue(masterStr.Substring(0, count));
if (count + 2 < masterStr.Length)
{
masterStr = masterStr.Substring(count + 2); // advance after the separator and the leading space
}
}
else
{
childEnum.Property.Value.SetValue(masterStr);
break;
}
childEnum.MoveNext();
}
}
}
}
return(result);
}
