public void Foreign_Class_Should_Return_Registered_Metadata_If_None_Supplied()
{
DependencyProperty dp = DependencyProperty.Register(
"Foreign_Class_Should_Return_Registered_Metadata_If_None_Supplied",
typeof(string),
typeof(TestClass1));
PropertyMetadata result1 = dp.GetMetadata(typeof(TestClass1));
PropertyMetadata result4 = dp.GetMetadata(typeof(TestClass4));
Assert.AreSame(result1, result4);
}
/// <inheritdoc/>
protected override bool ApplyTemplateCore()
{
this.ratingPanel = this.GetTemplateChild("Part_RatingPanel") as StackPanel;
if (this.ratingPanel == null)
{
throw new MissingTemplatePartException("Part_RatingPanel", typeof(StackPanel));
}
if (this.itemsSource.Count != 0)
{
if (!this.IsItemsSourceManual)
{
throw new InvalidOperationException(AutoGeneratedItemsCountExceptionMessage);
}
this.SetValue(AutoGeneratedItemsCountProperty, 0);
}
else
{
if (this.AutoGeneratedItemsCount == (int)AutoGeneratedItemsCountProperty.GetMetadata(typeof(int)).DefaultValue)
{
this.SetValue(AutoGeneratedItemsCountProperty, (int)AutoGeneratedItemsCountProperty.GetMetadata(typeof(int)).DefaultValue);
}
this.GenerateRatingItems();
}
this.PopulateRatingPanel();
double coercedValue = RadMath.CoerceValue(this.Value, 0, this.itemsSource.Count);
if (this.Value != coercedValue)
{
this.SetValuePropertySilently(ValueProperty, coercedValue);
}
double defaultValue = (double)ValueProperty.GetMetadata(typeof(double)).DefaultValue;
if (this.Value != defaultValue)
{
this.HandleValueChange(defaultValue, this.Value);
}
this.UpdateDisplayValue();
this.UpdateFillRatio();
this.UpdateVisualState(false);
return(base.ApplyTemplateCore());
}
private PropertyMetadata GetMetadataClone(DependencyProperty property, Type type)
{
PropertyMetadata metadata = property.GetMetadata(type);
Tuple <DependencyProperty, Type> key = new Tuple <DependencyProperty, Type>(property, type);
if (metadata != null && this.properties.ContainsKey(key))
{
metadata = this.properties[key];
}
else
{
if (metadata == null)
{
metadata = new PropertyMetadata();
}
else
{
metadata = metadata.Clone();
}
this.properties.Add(key, metadata);
}
return(metadata);
}
private void AssertBinding(FrameworkElement targetElement, string targetName, DependencyProperty targetProperty,
string expectedBindingPath, BindingMode allowedBindingMode)
{
BindingExpression binding = targetElement.GetBindingExpression(targetProperty);
var errorMessage =
$"Invalid 'Binding' for the '{targetProperty.Name}' property of {targetName}.";
Assert.That(binding, Is.Not.Null, errorMessage);
Assert.That(binding.ParentBinding.Path.Path, Is.EqualTo(expectedBindingPath), errorMessage);
var allowedBindingModes = new List <BindingMode> {
allowedBindingMode
};
var metaData = (FrameworkPropertyMetadata)targetProperty.GetMetadata(targetElement);
if (allowedBindingMode == BindingMode.TwoWay && metaData.BindsTwoWayByDefault)
{
allowedBindingModes.Add(BindingMode.Default);
}
else if (allowedBindingMode == BindingMode.OneWay)
{
allowedBindingModes.Add(BindingMode.Default);
}
Assert.That(allowedBindingModes, Has.One.EqualTo(binding.ParentBinding.Mode), errorMessage);
}
internal static void OverrideMetadataWithCoerceMethod(this DependencyProperty property, Type forType, CoerceValueCallback coerceValueCallback)
{
var metadata = property.GetMetadata(property.OwnerType);
if (metadata.GetType() == typeof(PropertyMetadata))
{
property.OverrideMetadata(
forType,
new PropertyMetadata(
metadata.DefaultValue,
metadata.PropertyChangedCallback,
coerceValueCallback));
return;
}
if (metadata.GetType() == typeof(FrameworkPropertyMetadata))
{
var fpm = (FrameworkPropertyMetadata)metadata;
var flags = GetFlags(fpm);
property.OverrideMetadata(
forType,
new FrameworkPropertyMetadata(
metadata.DefaultValue,
flags,
metadata.PropertyChangedCallback,
coerceValueCallback,
fpm.IsAnimationProhibited,
fpm.DefaultUpdateSourceTrigger));
return;
}
var message = $"Can only be called for properties with metadata of type {typeof(PropertyMetadata)}";
throw new NotSupportedException(message);
}
private void SetupBinding(object source)
{
//sanity check
if (source == null)
{
return;
}
var boundObject = GetObjectFromPath(source, Path.Path);
if (boundObject == null)
{
return;
}
//set default BindingMode
if (Mode == BindingMode.Default)
{
if (bindingProperty.GetMetadata(bindingTarget) is FrameworkPropertyMetadata metadata &&
metadata.BindsTwoWayByDefault)
{
Mode = BindingMode.TwoWay;
}
else
{
Mode = BindingMode.OneWay;
}
}
/// <summary>
/// Sets the value of the specified target object and property, based on the specified source property.
/// </summary>
/// <param name="sourceProperty">The source property.</param>
/// <param name="targetElement">The target element.</param>
/// <param name="targetProperty">The target property.</param>
protected virtual void ApplyValue(DependencyProperty sourceProperty, FrameworkElement targetElement, DependencyProperty targetProperty)
{
if (sourceProperty == null)
{
throw new ArgumentNullException("sourceProperty");
}
else if (targetElement == null)
{
throw new ArgumentNullException("targetElement");
}
else if (targetProperty == null)
{
throw new ArgumentNullException("targetProperty");
}
// 8/22/2011 - If the property is not set on the column, then do not pass down to the element (10F-15E35C2E-480E)
// 1/27/2012 - Fixed issue with column default that differ from the column not getting passed down properly (197-16B573BD-0301)
if (DependencyPropertyHelper.GetValueSource(this, sourceProperty).BaseValueSource == BaseValueSource.Default &&
DefaultValuesEqual(sourceProperty.GetMetadata(this), targetProperty.GetMetadata(targetElement)))
{
targetElement.ClearValue(targetProperty);
}
else
{
targetElement.SetValue(targetProperty, this.GetValue(sourceProperty));
}
}
/// <summary>
/// Creates a new dependency property descriptor. A note on perf: We don't
/// pass the property descriptor down as the default member descriptor here. Doing
/// so takes the attributes off of the property descriptor, which can be costly if they
/// haven't been accessed yet. Instead, we wait until someone needs to access our
/// Attributes property and demand create the attributes at that time.
/// </summary>
internal DependencyObjectPropertyDescriptor(DependencyProperty dp, Type ownerType)
: base(string.Concat(dp.OwnerType.Name, ".", dp.Name), null)
{
_dp = dp;
_componentType = ownerType;
_metadata = _dp.GetMetadata(ownerType);
}
public static void GetNotificationParameters(DependencyObject target, DependencyProperty targetProperty, ref BindingMode bindingMode, ref UpdateSourceTrigger updateSourceTrigger)
{
#if WPF
if (target != null && targetProperty != null)
{
var metadata = targetProperty.GetMetadata(target);
if (metadata is FrameworkPropertyMetadata frameworkPropertyMetadata)
{
if (bindingMode == BindingMode.Default)
{
bindingMode = frameworkPropertyMetadata.BindsTwoWayByDefault ? BindingMode.TwoWay : BindingMode.OneWay;
}
if (updateSourceTrigger == UpdateSourceTrigger.Default)
{
updateSourceTrigger = frameworkPropertyMetadata.DefaultUpdateSourceTrigger;
}
}
}
#endif
if (updateSourceTrigger == UpdateSourceTrigger.Default)
{
updateSourceTrigger = UpdateSourceTrigger.PropertyChanged;
}
}
void TargetUpdated(object sender, DataTransferEventArgs e)
{
// Trigger a property changed callback as long as the new value equals the default value.
object current = DependencyObject.GetValue(DependencyProperty);
PropertyMetadata metaData = DependencyProperty.GetMetadata(DependencyObject);
bool equals = current == null ? metaData.DefaultValue == null : current.Equals(metaData.DefaultValue);
if (equals)
{
if (metaData.PropertyChangedCallback != null)
{
metaData.PropertyChangedCallback.Invoke(
DependencyObject,
new DependencyPropertyChangedEventArgs(
DependencyProperty,
current,
current));
}
}
else
{
// Once it is no longer the default value, we know it has been changed.
_frameworkElement.TargetUpdated -= TargetUpdated;
NotifyOnTargetUpdated = _prevNotifyOnTargetUpdated;
}
}
public void Should_Merge_Metadata_If_Supplied()
{
FrameworkPropertyMetadata metadata1 = new FrameworkPropertyMetadata(
"foo",
FrameworkPropertyMetadataOptions.Inherits,
this.PropertyChangedCallback1,
this.CoerceCallback1);
DependencyProperty dp = DependencyProperty.Register(
"Should_Merge_Metadata_If_Supplied",
typeof(string),
typeof(TestClass1),
metadata1);
FrameworkPropertyMetadata metadata2 = new FrameworkPropertyMetadata(
"bar",
FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsRender,
this.PropertyChangedCallback2,
this.CoerceCallback2);
dp.AddOwner(typeof(TestClass2), metadata2);
FrameworkPropertyMetadata result = dp.GetMetadata(typeof(TestClass2)) as FrameworkPropertyMetadata;
Assert.IsNotNull(result);
Assert.AreNotSame(metadata1, result);
Assert.AreSame(metadata2, result);
Assert.AreEqual("bar", result.DefaultValue);
Assert.IsTrue(result.Inherits);
Assert.IsTrue(result.AffectsRender);
Assert.AreEqual(2, result.PropertyChangedCallback.GetInvocationList().Length);
Assert.AreEqual(1, result.CoerceValueCallback.GetInvocationList().Length);
}
private static void RefreshCanExecute(DependencyProperty commandProperty, Type controlType, DependencyObject d, object value)
{
if (value == null)
{
return;
}
commandProperty.GetMetadata(controlType).PropertyChangedCallback(d, new DependencyPropertyChangedEventArgs(commandProperty, value, null));
}
private DependencyPropertyDescriptor(PropertyDescriptor property, Type componentType, DependencyProperty dependencyProperty)
: base(dependencyProperty.Name, null)
{
_property = property;
_componentType = componentType;
_dependencyProperty = dependencyProperty;
_metadata = dependencyProperty.GetMetadata(componentType);
}
public static void SetDefaultValue <TForClass>(this DependencyProperty property, object value)
where TForClass : DependencyObject
{
if (value == null)
{
if (property.PropertyType.IsValueType)
{
throw new ArgumentException("The new default value cannot be null.");
}
}
else
{
if (!property.PropertyType.IsInstanceOfType(value))
{
throw new ArgumentException("The new default value is not a valid type.");
}
}
PropertyMetadata newPmd;
PropertyMetadata pmd = property.GetMetadata(DependencyObjectType.FromSystemType(typeof(TForClass).BaseType ?? typeof(object)));
if (pmd is FrameworkPropertyMetadata)
{
FrameworkPropertyMetadata fpmd = pmd as FrameworkPropertyMetadata;
newPmd = new FrameworkPropertyMetadata()
{
IsAnimationProhibited = fpmd.IsAnimationProhibited,
DefaultUpdateSourceTrigger = fpmd.DefaultUpdateSourceTrigger,
AffectsRender = fpmd.AffectsRender,
AffectsMeasure = fpmd.AffectsMeasure,
AffectsArrange = fpmd.AffectsArrange,
AffectsParentMeasure = fpmd.AffectsParentMeasure,
AffectsParentArrange = fpmd.AffectsParentArrange,
BindsTwoWayByDefault = fpmd.BindsTwoWayByDefault,
Inherits = fpmd.Inherits,
IsNotDataBindable = fpmd.IsNotDataBindable,
Journal = fpmd.Journal,
OverridesInheritanceBehavior = fpmd.OverridesInheritanceBehavior,
SubPropertiesDoNotAffectRender = fpmd.SubPropertiesDoNotAffectRender
};
}
else
{
newPmd = new PropertyMetadata();
}
if (pmd != null)
{
newPmd.CoerceValueCallback = pmd.CoerceValueCallback;
newPmd.PropertyChangedCallback = pmd.PropertyChangedCallback;
}
newPmd.DefaultValue = value;
property.OverrideMetadata(typeof(TForClass), newPmd);
}
public static void Override(this DependencyProperty property,
Type elementType,
Action <DependencyObject, DependencyPropertyChangedEventArgs, PropertyChangedCallback> changed = null,
Func <DependencyObject, object, CoerceValueCallback, object> coerce = null,
Action <PropertyMetadata, PropertyMetadata> factory = null)
{
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
if (elementType == null)
{
throw new ArgumentNullException(nameof(elementType));
}
var oldPropertyMetadata = property.GetMetadata(elementType);
var propertyMetadataType = oldPropertyMetadata.GetType();
var newPropertyMetadata = (PropertyMetadata)Activator.CreateInstance(propertyMetadataType);
newPropertyMetadata.DefaultValue = oldPropertyMetadata.DefaultValue;
if (changed != null)
{
newPropertyMetadata.PropertyChangedCallback = (o, args) => changed(o, args, oldPropertyMetadata.PropertyChangedCallback);
}
if (coerce != null)
{
newPropertyMetadata.CoerceValueCallback = (o, args) => coerce(o, args, oldPropertyMetadata.CoerceValueCallback);
}
if (oldPropertyMetadata is UIPropertyMetadata oldUIPropertyMetadata &&
newPropertyMetadata is UIPropertyMetadata newUIPropertyMetadata)
{
newUIPropertyMetadata.IsAnimationProhibited = oldUIPropertyMetadata.IsAnimationProhibited;
}
if (oldPropertyMetadata is FrameworkPropertyMetadata oldFrameworkPropertyMetadata &&
newPropertyMetadata is FrameworkPropertyMetadata newFrameworkPropertyMetadata)
{
newFrameworkPropertyMetadata.AffectsArrange = oldFrameworkPropertyMetadata.AffectsArrange;
newFrameworkPropertyMetadata.AffectsMeasure = oldFrameworkPropertyMetadata.AffectsMeasure;
newFrameworkPropertyMetadata.AffectsParentArrange = oldFrameworkPropertyMetadata.AffectsParentArrange;
newFrameworkPropertyMetadata.AffectsParentMeasure = oldFrameworkPropertyMetadata.AffectsParentMeasure;
newFrameworkPropertyMetadata.AffectsRender = oldFrameworkPropertyMetadata.AffectsRender;
newFrameworkPropertyMetadata.BindsTwoWayByDefault = oldFrameworkPropertyMetadata.BindsTwoWayByDefault;
newFrameworkPropertyMetadata.DefaultUpdateSourceTrigger = oldFrameworkPropertyMetadata.DefaultUpdateSourceTrigger;
newFrameworkPropertyMetadata.Inherits = oldFrameworkPropertyMetadata.Inherits;
newFrameworkPropertyMetadata.IsNotDataBindable = oldFrameworkPropertyMetadata.IsNotDataBindable;
newFrameworkPropertyMetadata.Journal = oldFrameworkPropertyMetadata.Journal;
newFrameworkPropertyMetadata.SubPropertiesDoNotAffectRender = oldFrameworkPropertyMetadata.SubPropertiesDoNotAffectRender;
newFrameworkPropertyMetadata.OverridesInheritanceBehavior = oldFrameworkPropertyMetadata.OverridesInheritanceBehavior;
}
factory?.Invoke(newPropertyMetadata, oldPropertyMetadata);
property.OverrideMetadata(elementType, newPropertyMetadata);
}
public void TestAddOwnerNullMetadata()
{
DependencyProperty p = DependencyProperty.Register("TestAddOwnerNullMetadata", typeof(string), typeof(ObjectPoker));
p.AddOwner(typeof(SubclassPoker), null);
PropertyMetadata pm = p.GetMetadata(typeof(SubclassPoker));
Assert.IsNotNull(pm);
}
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
/// <summary>
/// Creates a new dependency property descriptor. A note on perf: We don't
/// pass the property descriptor down as the default member descriptor here. Doing
/// so gets the attributes off of the property descriptor, which can be costly if they
/// haven't been accessed yet. Instead, we wait until someone needs to access our
/// Attributes property and demand create the attributes at that time.
/// </summary>
private DependencyPropertyDescriptor(PropertyDescriptor property, string name, Type componentType, DependencyProperty dp, bool isAttached) : base(name, null)
{
Debug.Assert(property != null || !isAttached, "Demand-load of property descriptor is only supported for direct properties");
_property = property;
_componentType = componentType;
_dp = dp;
_isAttached = isAttached;
_metadata = _dp.GetMetadata(componentType);
}
private void UpdateBindingMode(DependencyObject targetObject, DependencyProperty targetProperty)
{
if (Mode != BindingMode.Default)
{
return;
}
Mode = targetProperty.GetMetadata(targetObject.GetType()) is FrameworkPropertyMetadata {
BindsTwoWayByDefault : true
}
private void OnColumnCountChanged(int newValue)
{
if (newValue == 0)
{
// If we have zero columns (i.e. binding mode), then assign the DependencyProperty default value
var metadata = ColumnCountProperty.GetMetadata(typeof(AnimatedSlotPanel));
ColumnCount = (int)metadata.DefaultValue;
}
// Simulate a resize operation to prevent unpredictable animations
resizeInProgress = true;
}
public static void RemovePropertyChanged(DependencyProperty dp, DependencyObjectType type,
DependencyPropertyChangedEventHandler handler)
{
var hcpm = dp.GetMetadata(type) as HandleChangesPropertyMetadata;
if (hcpm == null)
{
throw new ArgumentException();
}
hcpm.RemovePropertyChanged(type, handler);
}
public void Should_Use_Base_Metadata_If_None_Supplied()
{
FrameworkPropertyMetadata metadata = new FrameworkPropertyMetadata("foo");
DependencyProperty dp = DependencyProperty.Register(
"Should_Use_Base_Metadata_If_None_Supplied",
typeof(string),
typeof(TestClass1),
metadata);
dp.AddOwner(typeof(TestClass2));
dp.AddOwner(typeof(TestClass3));
PropertyMetadata metadata1 = dp.GetMetadata(typeof(TestClass1));
PropertyMetadata metadata2 = dp.GetMetadata(typeof(TestClass2));
PropertyMetadata metadata3 = dp.GetMetadata(typeof(TestClass3));
Assert.AreSame(metadata, metadata1);
Assert.AreSame(metadata1, metadata2);
Assert.AreSame(metadata2, metadata3);
}
public void Registered_Class_Should_Return_Metadata_If_None_Supplied()
{
DependencyProperty dp = DependencyProperty.Register(
"Registered_Class_Should_Return_Metadata_If_None_Supplied",
typeof(string),
typeof(TestClass1));
PropertyMetadata result = dp.GetMetadata(typeof(TestClass1));
Assert.IsNotNull(result);
}
public static PropertyMetadata GetPropertyMetadata(DependencyProperty dependencyProperty, Type type)
{
if (typeof(DependencyObject).IsAssignableFrom(type))
{
PropertyMetadata metadata = dependencyProperty.GetMetadata(type);
if (metadata != null)
{
return(metadata);
}
}
return(dependencyProperty.DefaultMetadata);
}
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
/// <summary>
/// Creates a new dependency property descriptor. A note on perf: We don't
/// pass the property descriptor down as the default member descriptor here. Doing
/// so takes the attributes off of the property descriptor, which can be costly if they
/// haven't been accessed yet. Instead, we wait until someone needs to access our
/// Attributes property and demand create the attributes at that time.
/// </summary>
internal DependencyObjectPropertyDescriptor(PropertyDescriptor property, DependencyProperty dp, Type objectType)
: base(dp.Name, null)
{
_property = property;
_dp = dp;
Debug.Assert(property != null && dp != null);
Debug.Assert(!(property is DependencyObjectPropertyDescriptor), "Wrapping a DP in a DP");
_componentType = property.ComponentType;
_metadata = _dp.GetMetadata(objectType);
}
internal virtual void OnComponentTypeChanged()
{
if (this.owner != null)
{
this.SetStepFromDateTime(this.owner.Step);
}
else
{
this.Step = (int)StepProperty.GetMetadata(typeof(int)).DefaultValue;
}
this.IsLoopingEnabled = this.GetCanLoop();
}
public void Registered_Class_Should_Return_Metadata()
{
FrameworkPropertyMetadata metadata = new FrameworkPropertyMetadata("foo");
DependencyProperty dp = DependencyProperty.Register(
"Registered_Class_Should_Return_Metadata",
typeof(string),
typeof(TestClass1),
metadata);
PropertyMetadata result = dp.GetMetadata(typeof(TestClass1));
Assert.AreSame(metadata, result);
}
// Token: 0x06001C70 RID: 7280 RVA: 0x00085BF8 File Offset: 0x00083DF8
internal static PriorityBindingExpression CreateBindingExpression(DependencyObject d, DependencyProperty dp, PriorityBinding binding, BindingExpressionBase owner)
{
FrameworkPropertyMetadata frameworkPropertyMetadata = dp.GetMetadata(d.DependencyObjectType) as FrameworkPropertyMetadata;
if ((frameworkPropertyMetadata != null && !frameworkPropertyMetadata.IsDataBindingAllowed) || dp.ReadOnly)
{
throw new ArgumentException(SR.Get("PropertyNotBindable", new object[]
{
dp.Name
}), "dp");
}
return(new PriorityBindingExpression(binding, owner));
}
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));
}
}
public void ResetValue(DependencyObject _this, DependencyProperty dp)
{
var md = dp.GetMetadata(_this.GetType());
if (_this.GetValue(dp).Equals(md.DefaultValue))
{
var args = new DependencyPropertyChangedEventArgs(dp, DependencyProperty.UnsetValue, md.DefaultValue);
md.PropertyChangedCallback?.Invoke(_this, args);
}
else
{
_this.ClearValue(dp);
}
}
private static void DisableWindowsTransparency(DependencyProperty dp, Type type)
{
try {
var m = dp.GetMetadata(type);
var p = m.GetType().GetProperty("Sealed",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
?? throw new Exception(@"Sealed property is missing");
p.SetValue(m, false);
m.CoerceValueCallback = (d, o) => false;
p.SetValue(m, true);
} catch (Exception e) {
Logging.Error(e);
}
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
// Create a new BindingExpression from the given Binding description
internal static MultiBindingExpression CreateBindingExpression(DependencyObject d, DependencyProperty dp, MultiBinding binding, BindingExpressionBase owner)
{
FrameworkPropertyMetadata fwMetaData = dp.GetMetadata(d.DependencyObjectType) as FrameworkPropertyMetadata;
if ((fwMetaData != null && !fwMetaData.IsDataBindingAllowed) || dp.ReadOnly)
throw new ArgumentException(SR.Get(SRID.PropertyNotBindable, dp.Name), "dp");
// create the BindingExpression
MultiBindingExpression bindExpr = new MultiBindingExpression(binding, owner);
bindExpr.ResolvePropertyDefaultSettings(binding.Mode, binding.UpdateSourceTrigger, fwMetaData);
return bindExpr;
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
// Create a new BindingExpression from the given Binding description
internal static PriorityBindingExpression CreateBindingExpression(DependencyObject d, DependencyProperty dp, PriorityBinding binding, BindingExpressionBase owner)
{
FrameworkPropertyMetadata fwMetaData = dp.GetMetadata(d.DependencyObjectType) as FrameworkPropertyMetadata;
if ((fwMetaData != null && !fwMetaData.IsDataBindingAllowed) || dp.ReadOnly)
throw new ArgumentException(SR.Get(SRID.PropertyNotBindable, dp.Name), "dp");
// create the BindingExpression
PriorityBindingExpression bindExpr = new PriorityBindingExpression(binding, owner);
return bindExpr;
}
// Writes a value of an individual non-inheritable property in form of attribute string.
// If the value cannot be serialized as a string, adds the property to a collection of complexProperties.
// To minimize the amount of xaml produced, the property is skipped if its value is equal to its default value
// for the given element type - the propertyOwnerType.
// The flag onlyAffected=false means that we want to output all properties independently on
// if they are equal to their default values or not.
private static void WriteNoninheritableProperty(XmlWriter xmlWriter, DependencyProperty property, object propertyValue, Type propertyOwnerType, bool onlyAffected, DependencyObject complexProperties, object localValue)
{
bool write = false;
if (propertyValue != null &&
propertyValue != DependencyProperty.UnsetValue)
{
if (!onlyAffected)
{
write = true;
}
else
{
PropertyMetadata metadata = property.GetMetadata(propertyOwnerType);
write = (metadata == null) || !(TextSchema.ValuesAreEqual(propertyValue, /*defaultValue*/metadata.DefaultValue) && localValue == DependencyProperty.UnsetValue);
}
}
if (write)
{
string stringValue = DPTypeDescriptorContext.GetStringValue(property, propertyValue);
if (stringValue != null)
{
stringValue = FilterNaNStringValueForDoublePropertyType(stringValue, property.PropertyType);
// For the property name in this case we safe to use simple name only;
// as noninheritable property would never require TypeName.PropertyName notation
// for attribute syntax.
xmlWriter.WriteAttributeString(property.Name, stringValue);
}
else
{
complexProperties.SetValue(property, propertyValue);
}
}
}
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));
}
protected override void OnPropertyChanged(DependencyProperty property, object newValue, object oldValue)
{
var type = GetType();
var metadata = property.GetMetadata(type);
// Handle metadata properties when property value is changed.
if (metadata.AffectsMeasure)
InvalidateMeasure();
if (metadata.AffectsArrange)
InvalidateArrange();
if (metadata.AffectsParentArrange)
Parent?.InvalidateArrange();
if (metadata.AffectsParentMeasure)
Parent?.InvalidateMeasure();
}
private static BindingMode GetDefaultBindingMode(DependencyObject dependencyObject, DependencyProperty dependencyProperty)
{
FrameworkPropertyMetadata frameworkPropertyMetadata = dependencyProperty.GetMetadata(dependencyObject.GetType()) as FrameworkPropertyMetadata;
return frameworkPropertyMetadata != null && frameworkPropertyMetadata.BindsTwoWayByDefault ? BindingMode.TwoWay : BindingMode.OneWay;
}
[FriendAccessAllowed] // Built into Core, also used by Framework.
internal static bool IsPropertyAnimatable(
DependencyObject d,
DependencyProperty dp)
{
//
if (dp.PropertyType != typeof(Visual3DCollection) && dp.ReadOnly)
{
return false;
}
UIPropertyMetadata uiMetadata = dp.GetMetadata(d.DependencyObjectType) as UIPropertyMetadata;
if ( uiMetadata != null
&& uiMetadata.IsAnimationProhibited)
{
return false;
}
return true;
}
private static AnimationStorage CreateStorage(
DependencyObject d,
DependencyProperty dp)
{
AnimationStorage newStorage;
if (dp.GetMetadata(d.DependencyObjectType) is IndependentlyAnimatedPropertyMetadata)
{
newStorage = CreateIndependentAnimationStorageForType(dp.PropertyType);
}
else
{
newStorage = new AnimationStorage();
}
newStorage.Initialize(d, dp);
return newStorage;
}
