/// <summary>
/// Updates the binding source property.
/// </summary>
/// <param name="boundProperty"></param>
/// <param name="newValue"></param>
public void UpdateBindingSourceProperty(RadProperty boundProperty, object newValue)
{
if (this.options == PropertyBindingOptions.TwoWay)
{
this.BindingSourceObject.SetValue(toProperty, newValue);
}
}
/// <summary>
/// Initializes a new instance of the RadPropertyBinding class.
/// </summary>
/// <param name="bindingSourceObject"></param>
/// <param name="fromProperty"></param>
/// <param name="bindingSourceProperty"></param>
/// <param name="options"></param>
public RadPropertyBinding(RadObject bindingSourceObject, RadProperty fromProperty, RadProperty bindingSourceProperty, PropertyBindingOptions options)
{
this.bindingSourceObject = bindingSourceObject;
this.fromProperty = fromProperty;
this.toProperty = bindingSourceProperty;
this.options = options;
}
public static object Deserialize(string fullName, string propertyName, string value)
{
if (PropertyReader.directConverters.ContainsKey(propertyName))
{
return(PropertyReader.directConverters[propertyName](value));
}
if (PropertyReader.typeDescriptorConverters.ContainsKey(propertyName))
{
return(PropertyReader.typeDescriptorConverters[propertyName].Converter?.ConvertFromString((ITypeDescriptorContext)null, PropertyReader.serializationCulture, value));
}
object obj = (object)null;
try
{
RadProperty property = XmlPropertySetting.DeserializePropertySafe(!string.IsNullOrEmpty(fullName) ? fullName : propertyName);
if (property != null)
{
obj = XmlPropertySetting.DeserializeValue(property, value);
}
}
catch
{
}
return(obj);
}
internal void Dispose()
{
++this.lockComposeCount;
++this.lockValueUpdateCount;
if (this.owner != null)
{
this.owner.RemoveBinding(this);
}
if (this.boundObjects != null)
{
for (int index = this.boundObjects.Count - 1; index >= 0; --index)
{
PropertyBoundObject boundObject = this.boundObjects[index];
RadObject radObject = boundObject.Object;
if (radObject != null && !radObject.IsDisposed && !radObject.IsDisposing)
{
int num = (int)radObject.UnbindProperty(boundObject.Property);
}
}
this.boundObjects.Clear();
}
this.property = (RadProperty)null;
this.metadata = (RadPropertyMetadata)null;
this.owner = (RadObject)null;
this.propertyBinding = (PropertyBinding)null;
this.animationSetting = (AnimatedPropertySetting)null;
this.styleSetting = (IPropertySetting)null;
}
public RadPropertyValue GetEntry(RadProperty prop, bool createNew)
{
if (prop == null)
{
throw new ArgumentNullException("RadProperty");
}
//check for property mapping
if (this.propertyMapper != null)
{
RadProperty mappedProperty = this.propertyMapper(prop);
if (mappedProperty != null)
{
prop = mappedProperty;
}
}
RadPropertyValue entry;
if (!this.entries.TryGetValue(prop.GlobalIndex, out entry) && createNew)
{
entry = new RadPropertyValue(this.owner, prop);
this.entries[prop.GlobalIndex] = entry;
}
return(entry);
}
private static RadProperty RegisterCommon(string name, Type propertyType, Type ownerType, AttachedPropertyUsage usage, RadPropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback)
{
RadProperty.FromNameKey key1 = new RadProperty.FromNameKey(name, ownerType);
lock (RadProperty.Synchronized)
{
if (RadProperty.PropertyFromName.Contains(key1))
{
object[] objArray1 = new object[] { name, ownerType.Name };
throw new ArgumentException(string.Format("Property already registered", objArray1));
}
}
if (defaultMetadata == null)
{
defaultMetadata = RadProperty.AutoGeneratePropertyMetadata(propertyType, validateValueCallback, name, ownerType);
}
else
{
if (!defaultMetadata.DefaultValueWasSet())
{
defaultMetadata.DefaultValue = RadProperty.AutoGenerateDefaultValue(propertyType);
}
//TODO:
//RadProperty.ValidateMetadataDefaultValue(defaultMetadata, propertyType, validateValueCallback);
}
defaultMetadata.SetAttachedPropertyUsage(usage);
RadProperty property1 = new RadProperty(name, propertyType, ownerType, defaultMetadata, validateValueCallback);
defaultMetadata.Seal(property1, null);
lock (RadProperty.Synchronized)
{
RadProperty.PropertyFromName[key1] = property1;
}
return(property1);
}
private void SetupOverrideMetadata(Type forType, RadPropertyMetadata typeMetadata, out RadObjectType dType, out RadPropertyMetadata baseMetadata)
{
if (forType == null)
{
throw new ArgumentNullException("forType");
}
if (typeMetadata == null)
{
throw new ArgumentNullException("typeMetadata");
}
if (typeMetadata.Sealed)
{
throw new ArgumentException(string.Format("TypeMetadataAlreadyInUse", new object[0]));
}
if (!typeof(RadObject).IsAssignableFrom(forType))
{
object[] objArray1 = new object[] { forType.Name };
throw new ArgumentException(string.Format("TypeMustBeRadObjectDerived {0}", objArray1));
}
if (typeMetadata.IsDefaultValueModified)
{
RadProperty.ValidateMetadataDefaultValue(typeMetadata, this.PropertyType, this.ValidateValueCallback);
}
dType = RadObjectType.FromSystemType(forType);
baseMetadata = this.GetMetadata(dType.BaseType);
if (!baseMetadata.GetType().IsAssignableFrom(typeMetadata.GetType()))
{
throw new ArgumentException(string.Format("OverridingMetadataDoesNotMatchBaseMetadataType", new object[0]));
}
}
/// <summary>
/// Initializes a new instance of the RadPropertyBinding class.
/// </summary>
/// <param name="sourceObject"></param>
/// <param name="boundProperty"></param>
/// <param name="sourceProperty"></param>
/// <param name="options"></param>
public PropertyBinding(RadObject sourceObject, RadProperty boundProperty, RadProperty sourceProperty, PropertyBindingOptions options)
{
this.sourceObject = new WeakReference(sourceObject);
this.boundProperty = boundProperty;
this.sourceProperty = sourceProperty;
this.options = options;
}
/// <summary>
/// Checks needed conditions to perform property update.
/// </summary>
/// <param name="propVal"></param>
/// <param name="value"></param>
internal void EnsurePropertySet(RadPropertyValue propVal, object value)
{
//1. It should not be marked as "Read-only"
if (propVal.Metadata.ReadOnly)
{
throw new ArgumentException("Attemt to modify the value of a read-only property");
}
//2. Type of the specified value should match property type
if (value != null && value != RadProperty.UnsetValue)
{
if (!RadProperty.IsValidType(value, propVal.Property.PropertyType))
{
throw new ArgumentException("New value does not match declared property type.");
}
}
//3. Is value valid - use metadata's defined callback
if (propVal.Property.ValidateValueCallback != null)
{
if (!propVal.Property.ValidateValueCallback(value, this))
{
throw new ArgumentException("Specified value " + value.ToString() + " is not valid for property " + propVal.Property.Name);
}
}
}
public RadPropertyChangingEventArgs(RadProperty property, object oldValue, object newValue, RadPropertyMetadata metadata)
{
this.property = property;
this.oldValue = oldValue;
this.newValue = newValue;
this.metadata = metadata;
}
public static RadProperty FindProperty(
Type currentType,
string propertyName,
bool fallback)
{
if (string.IsNullOrEmpty(propertyName))
{
return((RadProperty)null);
}
string[] strArray = propertyName.Split('.');
if (strArray.Length > 1)
{
propertyName = strArray[strArray.Length - 1];
}
RadProperty safe = RadProperty.FindSafe(currentType, propertyName);
if (safe == null && fallback)
{
for (currentType = currentType.BaseType; (object)currentType != null && (object)currentType != (object)typeof(RadObject); currentType = currentType.BaseType)
{
safe = RadProperty.FindSafe(currentType, propertyName);
if (safe == null && (currentType.Name == "LightVisualElement" || currentType.Name == "UIChartElement"))
{
safe = RadProperty.FindSafe(currentType, "Border" + propertyName);
}
if (safe != null)
{
break;
}
}
}
return(safe);
}
private List <IPropertyChangeListener> GetPropertyChangeListeners(RadProperty radProperty)
{
List <IPropertyChangeListener> changeListeners;
elementPropertyChangeListeners.TryGetValue(radProperty.PropertyKey, out changeListeners);
return(changeListeners);
}
public void ApplyValue(RadObject element)
{
string propertyName = this.Name;
if (this.PropertyMapper != null)
{
propertyName = this.PropertyMapper(propertyName, element);
}
if (this.property == null)
{
this.property = PropertySetting.FindProperty(element.GetType(), propertyName, true);
}
if (this.property != null && (!this.property.OwnerType.IsAssignableFrom(element.GetType()) || this.property.Name != propertyName))
{
this.property = PropertySetting.FindProperty(element.GetType(), propertyName, true);
}
if (this.property == null)
{
return;
}
if (this.endValue != null)
{
if (this.animatedSetting == null)
{
this.animatedSetting = new AnimatedPropertySetting();
this.animatedSetting.Property = this.property;
this.animatedSetting.StartValue = this.value;
this.animatedSetting.EndValue = this.endValue;
}
this.animatedSetting.IsStyleSetting = true;
this.animatedSetting.Property = this.property;
this.animatedSetting.ApplyValue(element);
}
int num = (int)element.AddStylePropertySetting((IPropertySetting)this);
}
public ValueUpdateResult BindProperty(
RadProperty propertyToBind,
RadObject sourceObject,
RadProperty sourceProperty,
PropertyBindingOptions options)
{
if (sourceObject == null)
{
throw new ArgumentNullException("Binding source object");
}
if (sourceObject.IsDisposing || sourceObject.IsDisposed)
{
return(ValueUpdateResult.NotUpdated);
}
RadPropertyValue entry = this.propertyValues.GetEntry(propertyToBind, true);
if (entry.PropertyBinding != null)
{
entry.BeginUpdate(true, false);
int num = (int)this.ResetValueCore(entry, ValueResetFlags.Binding);
entry.EndUpdate(true, false);
}
PropertyBinding binding = new PropertyBinding(sourceObject, propertyToBind, sourceProperty, options);
ValueUpdateResult valueUpdateResult = this.SetValueCore(entry, (object)binding, (object)null, ValueSource.PropertyBinding);
if ((options & PropertyBindingOptions.NoChangeNotify) == (PropertyBindingOptions)0)
{
sourceObject.OnPropertyBoundExternally(binding, this);
}
return(valueUpdateResult);
}
protected internal virtual object GetInheritedValue(RadProperty property)
{
if (this.GetBitState(1L) || this.GetBitState(2L))
{
return(RadProperty.UnsetValue);
}
int globalIndex = property.GlobalIndex;
System.Type ownerType = property.OwnerType;
object obj = RadProperty.UnsetValue;
for (RadObject inheritanceParent = this.InheritanceParent; inheritanceParent != null; inheritanceParent = inheritanceParent.InheritanceParent)
{
if (ownerType.IsInstanceOfType((object)inheritanceParent))
{
RadPropertyValue entry = inheritanceParent.propertyValues.GetEntry(property, false);
if (entry != null)
{
obj = entry.GetCurrentValue(true);
break;
}
}
}
return(obj);
}
private IPropertySetting MapProperty(
PropertySettingCollection.InheritedSetting inheritedSetting,
RadElement element)
{
if (element == null)
{
return((IPropertySetting)null);
}
RadProperty property = element.MapStyleProperty(inheritedSetting.property, inheritedSetting.settingType);
if (property == null)
{
return((IPropertySetting)null);
}
PropertySettingCollection.InheritedSetting key = new PropertySettingCollection.InheritedSetting(inheritedSetting.settingType, property);
IPropertySetting propertySetting;
if (!this.mappedSettings.TryGetValue(key, out propertySetting))
{
lock (Locker.SyncObj)
{
if (!this.mappedSettings.TryGetValue(key, out propertySetting))
{
propertySetting.Property = property;
this.mappedSettings[key] = propertySetting;
}
}
}
return(propertySetting);
}
public void SetValueAtDesignTime(RadProperty property, object value)
{
RadPropertyValue entry = this.propertyValues.GetEntry(property, true);
entry.IsSetAtDesignTime = true;
int num = (int)this.SetValueCore(entry, (object)null, value, ValueSource.Local);
}
public AnimatedPropertySetting(RadProperty property, int frames, int interval, object step)
{
this.property = property;
this.frames = frames;
this.interval = interval;
this.step = step;
}
private IPropertySetting MapProperty(InheritedSetting inheritedSetting, RadElement element)
{
if (element == null)
{
return(null);
}
RadProperty mappedProperty = element.MapStyleProperty(inheritedSetting.property, inheritedSetting.settingType);
if (mappedProperty == null)
{
return(null);
}
InheritedSetting newInheritedSetting = new InheritedSetting(inheritedSetting.settingType, mappedProperty);
IPropertySetting newSetting;
if (!mappedSettings.TryGetValue(newInheritedSetting, out newSetting))
{
lock (Locker.SyncObj)
{
//double check concurrency pattern
if (!mappedSettings.TryGetValue(newInheritedSetting, out newSetting))
{
newSetting = inheritedSetting.setting.Clone() as IPropertySetting;
newSetting.Property = mappedProperty;
mappedSettings[newInheritedSetting] = newSetting;
}
}
}
return(newSetting);
}
public ThemeSettingOverride(RadProperty property, object value, string visualState)
{
this.property = property;
this.visualState = visualState;
this.value = value;
this.propertySetting = new PropertySetting(this.property, this.value);
}
public RadPropertyMetadata Copy(RadProperty dp)
{
RadPropertyMetadata instance = this.CreateInstance();
instance.InvokeMerge(this, dp);
return(instance);
}
/// <summary>
/// Applies the specified value as Local for the desired property
/// and raises the flag IsLocalValueSetAtDesignTime for that property.
/// All design-time direct property modifications (e.g. item.Text = "Item1")
/// should be done through this method for the property to be properly serialized.
/// If a property is modified through a property grid, the custom property descriptor will automatically apply this logic.
/// </summary>
/// <param name="property"></param>
/// <param name="value"></param>
internal void SetValueAtDesignTime(RadProperty property, object value)
{
RadPropertyValue propVal = this.propertyValues.GetEntry(property, true);
propVal.IsSetAtDesignTime = true;
this.SetValueCore(propVal, null, value, ValueSource.Local);
}
/// <summary>
/// Searches up in the chain of InheritanceParents for a value for the specified property.
/// </summary>
/// <param name="property">The property to examine.</param>
/// <returns></returns>
protected internal virtual object GetInheritedValue(RadProperty property)
{
if (this.GetBitState(DisposingStateKey) || this.GetBitState(DisposedStateKey))
{
return(RadProperty.UnsetValue);
}
int propertyIndex = property.GlobalIndex;
Type propDeclaringType = property.OwnerType;
object value = RadProperty.UnsetValue;
RadObject parent = this.InheritanceParent;
while (parent != null)
{
if (propDeclaringType.IsInstanceOfType(parent))
{
RadPropertyValue propVal = parent.propertyValues.GetEntry(property, false);
if (propVal != null)
{
value = propVal.GetCurrentValue(true);
break;
}
}
parent = parent.InheritanceParent;
}
return(value);
}
protected object GetConvertedValue(RadProperty property, object value)
{
if (value != null &&
!property.PropertyType.IsAssignableFrom(value.GetType()) &&
!(value is Telerik.WinControls.Styles.PropertySettings.IValueProvider))
{
try
{
return(Convert.ChangeType(value, property.PropertyType));
}
catch (Exception ex)
{
throw new InvalidCastException(
string.Format(
"Error changing object type during deserialization. Property {0} of type: {1}, value type: {2}",
property.FullName,
property.PropertyType,
value.GetType().Name
),
ex);
}
}
else
{
return(value);
}
}
internal RadPropertyChangedEventArgs(RadProperty property, RadPropertyMetadata metadata, object oldValue, object newValue, bool isOldValueDeferred, bool isNewValueDeferred, ValueSource oldValueSource, ValueSource newValueSource)
: this(property, metadata, oldValue, newValue)
{
this._isOldValueDeferred = isOldValueDeferred;
this._isNewValueDeferred = isNewValueDeferred;
this._oldValueSource = oldValueSource;
this._newValueSource = newValueSource;
}
private static RadPropertyMetadata AutoGeneratePropertyMetadata(
Type propertyType,
ValidateValueCallback validateValueCallback,
string name,
Type ownerType)
{
return(new RadPropertyMetadata(RadProperty.AutoGenerateDefaultValue(propertyType)));
}
public static RadProperty Register(
string name,
Type propertyType,
Type ownerType,
RadPropertyMetadata typeMetadata)
{
return(RadProperty.Register(name, propertyType, ownerType, typeMetadata, (ValidateValueCallback)null));
}
public RadProperty GetDeserializedProperty()
{
if (this.tempPoroperty == null)
{
this.tempPoroperty = XmlPropertySetting.DeserializeProperty(this.Property);
}
return(this.tempPoroperty);
}
internal void InvokeMerge(RadPropertyMetadata baseMetadata, RadProperty dp)
{
if (baseMetadata.ReadOnly)
{
this._readOnlyKey = baseMetadata._readOnlyKey;
}
this.Merge(baseMetadata, dp);
}
internal RadPropertyChangedEventArgs(
RadProperty property,
RadPropertyMetadata metadata,
object value)
: this(property, metadata, value, value)
{
this._isASubPropertyChange = true;
}
