|
//---------------------------------------------------------------------------
//
// <copyright file="DependencyPropertyHelper.cs" company="Microsoft">
// Copyright (C) Microsoft Corporation. All rights reserved.
// </copyright>
//
// Description: Helper class for miscellaneous framework-level features related
// to DependencyProperties.
//
// See spec at http://teams/sites/Avalon/Specs/GetValueSource.mht
//
//---------------------------------------------------------------------------
using System;
using MS.Internal;
namespace System.Windows
{
/// <summary>
/// Source of a DependencyProperty value.
/// </summary>
public enum BaseValueSource
{
/// <summary> The source is not known by the Framework. </summary>
Unknown = BaseValueSourceInternal.Unknown,
/// <summary> Default value, as defined by property metadata. </summary>
Default = BaseValueSourceInternal.Default,
/// <summary> Inherited from an ancestor. </summary>
Inherited = BaseValueSourceInternal.Inherited,
/// <summary> Default Style for the current theme. </summary>
DefaultStyle = BaseValueSourceInternal.ThemeStyle,
/// <summary> Trigger in the default Style for the current theme. </summary>
DefaultStyleTrigger = BaseValueSourceInternal.ThemeStyleTrigger,
/// <summary> Style setter. </summary>
Style = BaseValueSourceInternal.Style,
/// <summary> Trigger in the Template. </summary>
TemplateTrigger = BaseValueSourceInternal.TemplateTrigger,
/// <summary> Trigger in the Style. </summary>
StyleTrigger = BaseValueSourceInternal.StyleTrigger,
/// <summary> Implicit Style reference. </summary>
ImplicitStyleReference = BaseValueSourceInternal.ImplicitReference,
/// <summary> Template that created the element. </summary>
ParentTemplate = BaseValueSourceInternal.ParentTemplate,
/// <summary> Trigger in the Template that created the element. </summary>
ParentTemplateTrigger = BaseValueSourceInternal.ParentTemplateTrigger,
/// <summary> Local value. </summary>
Local = BaseValueSourceInternal.Local,
}
/// <summary>
/// This struct contains the information returned from
/// DependencyPropertyHelper.GetValueSource.
/// </summary>
public struct ValueSource
{
internal ValueSource(BaseValueSourceInternal source, bool isExpression, bool isAnimated, bool isCoerced, bool isCurrent)
{
// this cast is justified because the public BaseValueSource enum
// values agree with the internal BaseValueSourceInternal enum values.
_baseValueSource = (BaseValueSource)source;
_isExpression = isExpression;
_isAnimated = isAnimated;
_isCoerced = isCoerced;
_isCurrent = isCurrent;
}
/// <summary>
/// The base value source.
/// </summary>
public BaseValueSource BaseValueSource
{
get { return _baseValueSource; }
}
/// <summary>
/// True if the value came from an Expression.
/// </summary>
public bool IsExpression
{
get { return _isExpression; }
}
/// <summary>
/// True if the value came from an animation.
/// </summary>
public bool IsAnimated
{
get { return _isAnimated; }
}
/// <summary>
/// True if the value was coerced.
/// </summary>
public bool IsCoerced
{
get { return _isCoerced; }
}
/// <summary>
/// True if the value was set by SetCurrentValue.
/// </summary>
public bool IsCurrent
{
get { return _isCurrent; }
}
#region Object overrides - required by FxCop
/// <summary>
/// Return the hash code for this ValueSource.
/// </summary>
public override int GetHashCode()
{
return _baseValueSource.GetHashCode();
}
/// <summary>
/// True if this ValueSource equals the argument.
/// </summary>
public override bool Equals(object o)
{
if (o is ValueSource)
{
ValueSource that = (ValueSource)o;
return this._baseValueSource == that._baseValueSource &&
this._isExpression == that._isExpression &&
this._isAnimated == that._isAnimated &&
this._isCoerced == that._isCoerced;
}
else
{
return false;
}
}
/// <summary>
/// True if the two arguments are equal.
/// </summary>
public static bool operator==(ValueSource vs1, ValueSource vs2)
{
return vs1.Equals(vs2);
}
/// <summary>
/// True if the two arguments are unequal.
/// </summary>
public static bool operator!=(ValueSource vs1, ValueSource vs2)
{
return !vs1.Equals(vs2);
}
#endregion Object overrides - required by FxCop
BaseValueSource _baseValueSource;
bool _isExpression;
bool _isAnimated;
bool _isCoerced;
bool _isCurrent;
}
/// <summary>
/// Helper class for miscellaneous framework-level features related
/// to DependencyProperties.
/// </summary>
public static class DependencyPropertyHelper
{
/// <summary>
/// Return the source of the value for the given property.
/// </summary>
public static ValueSource GetValueSource(DependencyObject dependencyObject, DependencyProperty dependencyProperty)
{
if (dependencyObject == null)
throw new ArgumentNullException(nameof(dependencyObject));
if (dependencyProperty == null)
throw new ArgumentNullException(nameof(dependencyProperty));
dependencyObject.VerifyAccess();
bool hasModifiers, isExpression, isAnimated, isCoerced, isCurrent;
BaseValueSourceInternal source = dependencyObject.GetValueSource(dependencyProperty, null, out hasModifiers, out isExpression, out isAnimated, out isCoerced, out isCurrent);
return new ValueSource(source, isExpression, isAnimated, isCoerced, isCurrent);
}
/// <summary>
/// Returns true if the given element belongs to an instance of a template
/// that defines a value for the given property that may change during runtime
/// based on changes elsewhere.
/// For example, values set by Binding, TemplateBinding, or DynamicResource.
/// </summary>
/// <param name="elementInTemplate">element belonging to a template instance</param>
/// <param name="dependencyProperty">property</param>
/// <remarks>
/// This method provides more detailed information in cases where
/// the BaseValueSource is ParentTemplate. The information is primarily
/// of use to diagnostic tools.
/// </remarks>
public static bool IsTemplatedValueDynamic(DependencyObject elementInTemplate, DependencyProperty dependencyProperty)
{
if (elementInTemplate == null)
throw new ArgumentNullException(nameof(elementInTemplate));
if (dependencyProperty == null)
throw new ArgumentNullException(nameof(dependencyProperty));
FrameworkObject child = new FrameworkObject(elementInTemplate);
DependencyObject templatedParent = child.TemplatedParent;
if (templatedParent == null)
{
throw new ArgumentException(SR.Get(SRID.ElementMustBelongToTemplate), nameof(elementInTemplate));
}
int templateChildIndex = child.TemplateChildIndex;
return StyleHelper.IsValueDynamic(templatedParent, templateChildIndex, dependencyProperty);
}
}
}
|