// Token: 0x06000C6A RID: 3178 RVA: 0x0002E850 File Offset: 0x0002CA50
private static void InvalidateResourceReferences(DependencyObject d, ResourcesChangeInfo info)
{
LocalValueEnumerator localValueEnumerator = d.GetLocalValueEnumerator();
int count = localValueEnumerator.Count;
if (count > 0)
{
ResourceReferenceExpression[] array = new ResourceReferenceExpression[count];
int num = 0;
while (localValueEnumerator.MoveNext())
{
LocalValueEntry localValueEntry = localValueEnumerator.Current;
ResourceReferenceExpression resourceReferenceExpression = localValueEntry.Value as ResourceReferenceExpression;
if (resourceReferenceExpression != null && info.Contains(resourceReferenceExpression.ResourceKey, false))
{
array[num] = resourceReferenceExpression;
num++;
}
}
ResourcesChangedEventArgs e = new ResourcesChangedEventArgs(info);
for (int i = 0; i < num; i++)
{
array[i].InvalidateExpressionValue(d, e);
}
}
}
private void OnResourcesChanged(object sender, ResourcesChangedEventArgs e)
{
if (e.Contains(resourceKey))
{
observableValue.BaseValue = GetResourceValue();
}
}
// Token: 0x0600087C RID: 2172 RVA: 0x0001BB60 File Offset: 0x00019D60
internal void InvalidateExpressionValue(object sender, EventArgs e)
{
if (this._targetObject == null)
{
return;
}
ResourcesChangedEventArgs resourcesChangedEventArgs = e as ResourcesChangedEventArgs;
if (resourcesChangedEventArgs != null)
{
if (!resourcesChangedEventArgs.Info.IsTreeChange)
{
this.InvalidateCacheValue();
}
else
{
this.InvalidateMentorCache();
}
}
else
{
this.InvalidateMentorCache();
}
this.InvalidateTargetProperty(sender, e);
}
public void Clear()
{
ResourcesChangedEventArgs e = ResourcesChangedEventArgs.FromKeyCollection(dictionary.Keys.ToArray());
dictionary.Clear();
ResourcesChanged.Raise(this, e);
}
public bool Remove(object key)
{
if (dictionary.Remove(key))
{
ResourcesChanged.Raise(this, ResourcesChangedEventArgs.FromKey(key));
return(true);
}
return(false);
}
protected virtual void OnResourcesChanged(ResourcesChangedEventArgs e)
{
if (DefaultStyleKey == null || !e.Contains(DefaultStyleKey))
{
return;
}
object value;
if (!TryGetResource(DefaultStyleKey, out value))
{
value = null;
}
SetValue(StyleProperty, value, BaseValueSource.Default);
}
private void OnMergedDictionariesCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
foreach (ResourceDictionary dictionary in e.OldItems)
{
dictionary.ResourcesChanged -= OnMergeDictionaryResourcesChanged;
}
foreach (ResourceDictionary dictionary in e.NewItems)
{
dictionary.ResourcesChanged += OnMergeDictionaryResourcesChanged;
}
if (e.Action != NotifyCollectionChangedAction.Move)
{
IEnumerable <object> keys = e.OldItems.Concat(e.NewItems).Cast <ResourceDictionary>().SelectMany(GetMergedDictionariesKeys);
ResourcesChanged.Raise(this, ResourcesChangedEventArgs.FromKeyCollection(keys));
}
}
/// <summary>
/// This event handler is called to invalidate the cached value held in
/// this expression. This is called under the following 3 scenarios
/// 1. InheritanceContext changes
/// 2. Logical tree changes
/// 3. ResourceDictionary changes
/// </summary>
internal void InvalidateExpressionValue(object sender, EventArgs e)
{
// VS has a scenario where a TreeWalk invalidates all reference expressions on a DependencyObject.
// If there is a dependency between RRE's,
// invalidating one RRE could cause _targetObject to be null on the other RRE. Hence this check.
if (_targetObject == null)
{
return;
}
ResourcesChangedEventArgs args = e as ResourcesChangedEventArgs;
if (args != null)
{
ResourcesChangeInfo info = args.Info;
if (!info.IsTreeChange)
{
// This will happen when
// 1. Theme changes
// 2. Entire ResourceDictionary in the ancestry changes
// 3. Single entry in a ResourceDictionary in the ancestry is changed
// In all of the above cases it is sufficient to re-evaluate the cache
// value alone. The mentor relation ships stay the same.
InvalidateCacheValue();
}
else
{
// This is the case of a logical tree change and hence we need to
// re-evaluate both the mentor and the cached value.
InvalidateMentorCache();
}
}
else
{
// There is no information provided by the EventArgs. Hence we
// pessimistically invalidate both the mentor and the cached value.
// This code path will execute when the InheritanceContext changes.
InvalidateMentorCache();
}
InvalidateTargetProperty(sender, e);
}
protected virtual void OnResourcesChanged(ResourcesChangedEventArgs e)
{
resourcesCache.Clear();
SetValue(StyleProperty, GetDefaultStyle(), BaseValueSource.Default);
}
private void RaiseResourcesChanged(ResourcesChangedEventArgs e)
{
OnResourcesChanged(e);
ResourcesChanged.Raise(this, e);
}
private void OnResourceDictionaryChanged(object sender, ResourcesChangedEventArgs e)
{
RaiseResourcesChanged(e);
}
private void OnParentResourcesChanged(object sender, ResourcesChangedEventArgs e)
{
RaiseResourcesChanged(e);
}
private void OnParentResourcesChanged(object sender, ResourcesChangedEventArgs e)
{
RaiseResourcesChanged(e);
}
private void OnResourcesChanged(object sender, ResourcesChangedEventArgs e)
{
if (e.Contains(resourceKey))
{
observableValue.Value = GetResourceValue();
}
}
private void OnMergeDictionaryResourcesChanged(object sender, ResourcesChangedEventArgs e)
{
ResourcesChanged.Raise(this, e);
}
public void Add(object key, object value)
{
dictionary[key] = value;
ResourcesChanged.Raise(this, ResourcesChangedEventArgs.FromKey(key));
}
private void RaiseResourcesChanged(ResourcesChangedEventArgs e)
{
OnResourcesChanged(e);
ResourcesChanged.Raise(this, e);
}
private void OnResourceDictionaryChanged(object sender, ResourcesChangedEventArgs e)
{
RaiseResourcesChanged(e);
}
private void OnResourcesChanged(object sender, ResourcesChangedEventArgs e)
{
ResourcesChanged.Raise(this, e);
}
private void OnResourcesChanged(object sender, ResourcesChangedEventArgs e)
{
ResourcesChanged.Raise(this, e);
}
/// <summary>
/// Invalidates all properties that reference a resource.
/// NOTE: The return value for this method indicates whether or not a ResourceReference
/// property was found on the given object. This is to take care of the special case when
/// programmatically changing a ResourceReference property value does not reflect on the
/// bit stored on FrameworkElement or FrameworkContentElement that indicates whether
/// the current instance has ResourceReference values set on it. This current operation
/// is a point of synchronization for this flag.
/// </summary>
/// <remarks>
/// This methods is called when one of the following operations occurred.
/// 1) A tree change
/// 2) A resource dictionary change
/// 3) A modification to a single entry in a dictionary
/// </remarks>
private static void InvalidateResourceReferences(
DependencyObject d,
ResourcesChangeInfo info)
{
Debug.Assert(d != null, "Must have non-null current node");
// Find properties that have resource reference value
LocalValueEnumerator localValues = d.GetLocalValueEnumerator();
int localValuesCount = localValues.Count;
if (localValuesCount > 0)
{
// Resource reference invalidation involves two passes - first to
// pick out what we need to invalidate, and the second to do the
// actual invalidation. This is needed because LocalValueEnumerator
// will halt if any local values have changed, which can happen
// depending on what people are doing in their OnPropertyChanged
// callback.
// The following array is used to track the ResourceReferenceExpressions that we find
ResourceReferenceExpression[] resources = new ResourceReferenceExpression[localValuesCount];
int invalidationCount = 0;
// Pass #1 - find what needs invalidation
while (localValues.MoveNext())
{
// Is this a resource reference?
ResourceReferenceExpression resource = localValues.Current.Value as ResourceReferenceExpression;
if (resource != null)
{
// Record this property if it is referring
// to a resource that is being changed
if (info.Contains(resource.ResourceKey, false /*isImplicitStyleKey*/))
{
resources[invalidationCount] = resource;
invalidationCount++;
}
}
}
ResourcesChangedEventArgs args = new ResourcesChangedEventArgs(info);
// Pass #2 - actually make the invalidation calls, now that we're
// outside the LocalValueEnumerator.
for (int i = 0; i < invalidationCount; i++)
{
// Let the resource reference throw away its cache
// and invalidate the property in which it's held
// re-evaluate expression
resources[i].InvalidateExpressionValue(d, args);
}
}
}
protected virtual void OnResourcesChanged(ResourcesChangedEventArgs e)
{
resourcesCache.Clear();
SetValue(StyleProperty, GetDefaultStyle(), BaseValueSource.Default);
}
