public void ClearValue(DependencyProperty dp)
{
if (IsSealed)
throw new InvalidOperationException("Cannot manipulate property values on a sealed Dependency Object");
_properties[dp] = null;
}
public DependencyPropertyChangedEventArgs(DependencyProperty property, object oldValue, object newValue)
: this()
{
Property = property;
OldValue = oldValue;
NewValue = newValue;
}
private DependencyPropertyDescriptor(PropertyDescriptor property, Type componentType, DependencyProperty dependencyProperty)
: base(dependencyProperty.Name, null)
{
_property = property;
_componentType = componentType;
_dependencyProperty = dependencyProperty;
_metadata = dependencyProperty.GetMetadata(componentType);
}
public void CoerceValue(DependencyProperty dp)
{
if (dp == null)
throw new ArgumentNullException("dp");
PropertyMetadata pm = dp.GetMetadata(this);
if (pm.CoerceValueCallback != null)
pm.CoerceValueCallback(this, GetValue(dp));
}
internal static DependencyPropertyDescriptor FromProperty(DependencyProperty dependencyProperty)
{
if (dependencyProperty == null)
throw new ArgumentNullException("dependencyProperty");
#region find PropertyDescriptor
PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(dependencyProperty.OwnerType);
/*foreach (PropertyDescriptor pd in pdc)
{
if (pd.Name == dependencyProperty.Name)
{
property = pd;
break;
}
}*/
var property = pdc.Cast<PropertyDescriptor>().FirstOrDefault(pd => pd.Name == dependencyProperty.Name);
#endregion
DependencyPropertyDescriptor dpd = null;
if (property != null)
{
if (!CachedDpd.TryGetValue(property, out dpd))
{
dpd = new DependencyPropertyDescriptor(property, dependencyProperty.OwnerType, dependencyProperty);
CachedDpd.TryAdd(property, dpd);
}
}
return dpd;
}
public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback)
{
ValidateRegisterParameters(name, propertyType, ownerType);
var dp = new DependencyProperty(true, name, propertyType, ownerType, defaultMetadata, validateValueCallback);
DependencyObject.Register(ownerType, dp);
return dp;
}
public static DependencyProperty Register(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback)
{
ValidateRegisterParameters(name, propertyType, ownerType);
var dp = new DependencyProperty(false, name, propertyType, ownerType, typeMetadata, validateValueCallback);
DependencyObject.Register(ownerType, dp);
// is this needed?
//dp.OverrideMetadata(ownerType, typeMetadata);
return dp;
}
internal DependencyPropertyKey(DependencyProperty dependencyProperty)
{
_dependencyProperty = dependencyProperty;
}
protected virtual void OnApply(DependencyProperty dp, Type targetType)
{
}
protected virtual bool ShouldSerializeProperty(DependencyProperty dp)
{
throw new NotImplementedException("DependencyObject - ShouldSerializeProperty(DependencyProperty dp)");
}
public void SetValue(DependencyProperty dp, object value)
{
if (IsSealed)
throw new InvalidOperationException("Cannot manipulate property values on a sealed Dependency Object");
// if (dp.ReadOnly)
// throw new InvalidOperationException("Cannot manipulate read-only Dependency Property");
if (dp == null)
throw new ArgumentNullException("dp");
if (!dp.IsValidType(value))
throw new ArgumentException("Value not of the correct type for this Dependency Property");
ValidateValueCallback validate = dp.ValidateValueCallback;
if (validate != null && !validate(value))
throw new ArgumentException("Value does not validate");
object oldValue = null;
if(_properties.ContainsKey(dp))
oldValue = _properties[dp];
if (!Equals(oldValue, value))
{
_properties[dp] = value;
var property = DependencyPropertyDescriptor.FromProperty(dp);
if (property != null)
property.OnValueChanged(this);
OnPropertyChanged(new DependencyPropertyChangedEventArgs(dp, oldValue, value));
}
}
public object ReadLocalValue(DependencyProperty dp)
{
object val = _properties[dp];
return val == null ? DependencyProperty.UnsetValue : val;
}
public void InvalidateProperty(DependencyProperty dp)
{
throw new NotImplementedException("DependencyObject - InvalidateProperty(DependencyProperty dp)");
}
public object GetValue(DependencyProperty dp)
{
if (dp == null)
throw new ArgumentNullException("dp");
if (_properties.ContainsKey(dp))
{
object val = _properties[dp];
return val ?? dp.DefaultMetadata.DefaultValue;
//return val == null ? dp.DefaultMetadata.DefaultValue : val;
}
return dp.DefaultMetadata.DefaultValue;
}
internal LocalValueEntry(DependencyProperty property, object value)
{
_property = property;
_value = value;
}
internal DependencyPropertyKey(DependencyProperty dependencyProperty)
{
_dependencyProperty = dependencyProperty;
}
protected virtual void Merge(PropertyMetadata baseMetadata, DependencyProperty dp)
{
if (baseMetadata == null)
throw new ArgumentNullException("baseMetadata");
if (dp == null)
throw new ArgumentNullException("dp");
if (_defaultValue == null)
_defaultValue = baseMetadata._defaultValue;
if (_propertyChangedCallback == null)
_propertyChangedCallback = baseMetadata._propertyChangedCallback;
if (_coerceValueCallback == null)
_coerceValueCallback = baseMetadata._coerceValueCallback;
}
internal static void Register(Type t, DependencyProperty dp)
{
if (!PropertyDeclarations.ContainsKey(t))
PropertyDeclarations[t] = new Dictionary<string, DependencyProperty>();
Dictionary<string, DependencyProperty> typeDeclarations = PropertyDeclarations[t];
if (!typeDeclarations.ContainsKey(dp.Name))
typeDeclarations[dp.Name] = dp;
else
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "'{0}' property was already registered by '{1}'.", dp.Name, t.Name));
}
internal void DoMerge(PropertyMetadata baseMetadata, DependencyProperty dp, Type targetType)
{
Merge(baseMetadata, dp);
OnApply(dp, targetType);
_isSealed = true;
}
protected void OnFreezablePropertyChanged(DependencyObject oldValue, DependencyObject newValue, DependencyProperty property)
{
throw new NotImplementedException("Freezable.OnFreezablePropertyChanged");
}
