/// <summary>
/// Invalidate inheritable properties and resource
/// references during a tree change operation.
/// </summary>
internal static void InvalidateOnTreeChange(
FrameworkElement fe,
FrameworkContentElement fce,
DependencyObject parent,
bool isAddOperation)
{
Debug.Assert(fe != null || fce != null, "Node with the tree change notification must be an FE or an FCE.");
Debug.Assert(parent != null, "Must have a parent that the current node is connected to or disconnected from.");
// If the tree change is for a non-FE/FCE parent then we need to find
// the nearest FE/FCE parent inorder to propagate inheritance correctly.
FrameworkObject parentFO = new FrameworkObject(parent);
if (!parentFO.IsValid)
{
parent = parentFO.FrameworkParent.DO;
}
// We're interested in changes to the Template property that occur during
// the walk - if the template has changed we don't need to invalidate
// template-driven properties a second time. The HasTemplateChanged property
// is cleared on the first visit to each node, so that it means "template
// changed during the walk". But one relevant node isn't visited during
// the walk - the templated parent of the initial node. So we handle that now.
FrameworkObject fo = new FrameworkObject(fe, fce);
// Synchronize the ShouldLookupImplicitStyles flag with respect to the parent here
// because for the root node of a tree change UpdateStyleProperty happens right here
// in this method. And we need to have synchrnozed the ShouldLookupImplicitStyles
// before we re-query the Style property.
if (isAddOperation)
{
fo.SetShouldLookupImplicitStyles();
}
fo.Reset(fo.TemplatedParent);
fo.HasTemplateChanged = false;
DependencyObject d = (fe != null) ? (DependencyObject)fe : (DependencyObject)fce;
// during a tree walk to invalidate inherited properties, we typically
// call UpdateStyle from FE/FCE.InvalidateTreeDependentProperties. But
// for the root element of the tree change, we need to record old values
// for inherited properties before we've updated the inheritance parent;
// so do the updatestyle here before we record old values so that we
// capture any updates provided by styles.
if (fe != null)
{
if (fe.IsInitialized && !fe.HasLocalStyle)
{
// Clear the HasStyleChanged flag
fe.HasStyleChanged = false;
fe.HasStyleInvalidated = false;
fe.HasTemplateChanged = false;
fe.AncestorChangeInProgress = true;
fe.UpdateStyleProperty();
fe.AncestorChangeInProgress = false;
}
}
else
{
if (!fce.HasLocalStyle)
{
// Clear the HasStyleChanged flag
fce.HasStyleChanged = false;
fce.HasStyleInvalidated = false;
fce.AncestorChangeInProgress = true;
fce.UpdateStyleProperty();
fce.AncestorChangeInProgress = false;
}
}
if (HasChildren(fe, fce))
{
// Spin up a DescendentsWalker only when
// the current node has children to walk
// If there is another tree walk that has already visited the
// current node then we do not need to re-walk its sub-tree.
FrameworkContextData fcdata = FrameworkContextData.From(d.Dispatcher);
if (!fcdata.WasNodeVisited(d, TreeChangeDelegate))
{
// The TreeChangeInfo object is used here to track
// information that we have because we're doing a tree walk.
TreeChangeInfo parentInfo = new TreeChangeInfo(d, parent, isAddOperation);
// PrePostDescendentsWalker is used instead of the standard
// DescendentsWalker because we need a "post" callback to know when
// to pop the parent's InheritableProperties cache from the stack.
PrePostDescendentsWalker<TreeChangeInfo> walker = new PrePostDescendentsWalker<TreeChangeInfo>(
TreeWalkPriority.LogicalTree, TreeChangeDelegate, TreeChangePostDelegate, parentInfo);
fcdata.AddWalker(TreeChangeDelegate, walker);
try
{
walker.StartWalk(d);
}
finally
{
fcdata.RemoveWalker(TreeChangeDelegate, walker);
}
}
}
else
{
// Degenerate case when the current node is a leaf node and has no children.
TreeChangeInfo parentInfo = new TreeChangeInfo(d, parent, isAddOperation);
// Degenerate case of OnAncestorChanged for a single node
OnAncestorChanged(fe, fce, parentInfo);
// Degenerate case of OnPostAncestorChanged for a single node
OnPostAncestorChanged(d, parentInfo);
}
}
// Token: 0x06000C69 RID: 3177 RVA: 0x0002E674 File Offset: 0x0002C874
internal static void OnResourcesChanged(DependencyObject d, ResourcesChangeInfo info, bool raiseResourceChangedEvent)
{
bool flag = info.Contains(d.DependencyObjectType.SystemType, true);
bool isThemeChange = info.IsThemeChange;
bool isStyleResourcesChange = info.IsStyleResourcesChange;
bool isTemplateResourcesChange = info.IsTemplateResourcesChange;
bool flag2 = info.Container == d;
FrameworkObject frameworkObject = new FrameworkObject(d);
if (info.IsResourceAddOperation || info.IsCatastrophicDictionaryChange)
{
frameworkObject.SetShouldLookupImplicitStyles();
}
if (frameworkObject.IsFE)
{
FrameworkElement fe = frameworkObject.FE;
fe.HasStyleChanged = false;
fe.HasStyleInvalidated = false;
fe.HasTemplateChanged = false;
if (info.IsImplicitDataTemplateChange)
{
ContentPresenter contentPresenter = fe as ContentPresenter;
if (contentPresenter != null)
{
contentPresenter.ReevaluateTemplate();
}
}
if (fe.HasResourceReference)
{
TreeWalkHelper.InvalidateResourceReferences(fe, info);
if ((!isStyleResourcesChange && !isTemplateResourcesChange) || !flag2)
{
TreeWalkHelper.InvalidateStyleAndReferences(d, info, flag);
}
}
else if (flag && (fe.HasImplicitStyleFromResources || fe.Style == FrameworkElement.StyleProperty.GetMetadata(fe.DependencyObjectType).DefaultValue) && (!isStyleResourcesChange || !flag2))
{
fe.UpdateStyleProperty();
}
if (isThemeChange)
{
fe.UpdateThemeStyleProperty();
}
if (raiseResourceChangedEvent && fe.PotentiallyHasMentees)
{
fe.RaiseClrEvent(FrameworkElement.ResourcesChangedKey, new ResourcesChangedEventArgs(info));
return;
}
}
else
{
FrameworkContentElement fce = frameworkObject.FCE;
fce.HasStyleChanged = false;
fce.HasStyleInvalidated = false;
if (fce.HasResourceReference)
{
TreeWalkHelper.InvalidateResourceReferences(fce, info);
if ((!isStyleResourcesChange && !isTemplateResourcesChange) || !flag2)
{
TreeWalkHelper.InvalidateStyleAndReferences(d, info, flag);
}
}
else if (flag && (fce.HasImplicitStyleFromResources || fce.Style == FrameworkContentElement.StyleProperty.GetMetadata(fce.DependencyObjectType).DefaultValue) && (!isStyleResourcesChange || !flag2))
{
fce.UpdateStyleProperty();
}
if (isThemeChange)
{
fce.UpdateThemeStyleProperty();
}
if (raiseResourceChangedEvent && fce.PotentiallyHasMentees)
{
fce.RaiseClrEvent(FrameworkElement.ResourcesChangedKey, new ResourcesChangedEventArgs(info));
}
}
}
// Token: 0x06000C6B RID: 3179 RVA: 0x0002E8E0 File Offset: 0x0002CAE0
private static void InvalidateStyleAndReferences(DependencyObject d, ResourcesChangeInfo info, bool containsTypeOfKey)
{
FrameworkObject frameworkObject = new FrameworkObject(d);
if (frameworkObject.IsFE)
{
FrameworkElement fe = frameworkObject.FE;
if (containsTypeOfKey && !info.IsThemeChange && (fe.HasImplicitStyleFromResources || fe.Style == FrameworkElement.StyleProperty.GetMetadata(fe.DependencyObjectType).DefaultValue))
{
fe.UpdateStyleProperty();
}
if (fe.Style != null && fe.Style.HasResourceReferences && !fe.HasStyleChanged)
{
StyleHelper.InvalidateResourceDependents(d, info, ref fe.Style.ResourceDependents, false);
}
if (fe.TemplateInternal != null && fe.TemplateInternal.HasContainerResourceReferences)
{
StyleHelper.InvalidateResourceDependents(d, info, ref fe.TemplateInternal.ResourceDependents, false);
}
if (fe.TemplateChildIndex > 0)
{
FrameworkElement frameworkElement = (FrameworkElement)fe.TemplatedParent;
FrameworkTemplate templateInternal = frameworkElement.TemplateInternal;
if (!frameworkElement.HasTemplateChanged && templateInternal.HasChildResourceReferences)
{
StyleHelper.InvalidateResourceDependentsForChild(frameworkElement, fe, fe.TemplateChildIndex, info, templateInternal);
}
}
if (!info.IsThemeChange)
{
Style themeStyle = fe.ThemeStyle;
if (themeStyle != null && themeStyle.HasResourceReferences && themeStyle != fe.Style)
{
StyleHelper.InvalidateResourceDependents(d, info, ref themeStyle.ResourceDependents, false);
return;
}
}
}
else if (frameworkObject.IsFCE)
{
FrameworkContentElement fce = frameworkObject.FCE;
if (containsTypeOfKey && !info.IsThemeChange && (fce.HasImplicitStyleFromResources || fce.Style == FrameworkContentElement.StyleProperty.GetMetadata(fce.DependencyObjectType).DefaultValue))
{
fce.UpdateStyleProperty();
}
if (fce.Style != null && fce.Style.HasResourceReferences && !fce.HasStyleChanged)
{
StyleHelper.InvalidateResourceDependents(d, info, ref fce.Style.ResourceDependents, true);
}
if (fce.TemplateChildIndex > 0)
{
FrameworkElement frameworkElement2 = (FrameworkElement)fce.TemplatedParent;
FrameworkTemplate templateInternal2 = frameworkElement2.TemplateInternal;
if (!frameworkElement2.HasTemplateChanged && templateInternal2.HasChildResourceReferences)
{
StyleHelper.InvalidateResourceDependentsForChild(frameworkElement2, fce, fce.TemplateChildIndex, info, templateInternal2);
}
}
if (!info.IsThemeChange)
{
Style themeStyle2 = fce.ThemeStyle;
if (themeStyle2 != null && themeStyle2.HasResourceReferences && themeStyle2 != fce.Style)
{
StyleHelper.InvalidateResourceDependents(d, info, ref themeStyle2.ResourceDependents, false);
}
}
}
}
// Token: 0x06000C61 RID: 3169 RVA: 0x0002E1F8 File Offset: 0x0002C3F8
internal static void InvalidateOnTreeChange(FrameworkElement fe, FrameworkContentElement fce, DependencyObject parent, bool isAddOperation)
{
FrameworkObject frameworkObject = new FrameworkObject(parent);
if (!frameworkObject.IsValid)
{
parent = frameworkObject.FrameworkParent.DO;
}
FrameworkObject frameworkObject2 = new FrameworkObject(fe, fce);
if (isAddOperation)
{
frameworkObject2.SetShouldLookupImplicitStyles();
}
frameworkObject2.Reset(frameworkObject2.TemplatedParent);
frameworkObject2.HasTemplateChanged = false;
DependencyObject dependencyObject = (fe != null) ? fe : fce;
if (fe != null)
{
if (fe.IsInitialized && !fe.HasLocalStyle)
{
fe.HasStyleChanged = false;
fe.HasStyleInvalidated = false;
fe.HasTemplateChanged = false;
fe.AncestorChangeInProgress = true;
fe.UpdateStyleProperty();
fe.AncestorChangeInProgress = false;
}
}
else if (!fce.HasLocalStyle)
{
fce.HasStyleChanged = false;
fce.HasStyleInvalidated = false;
fce.AncestorChangeInProgress = true;
fce.UpdateStyleProperty();
fce.AncestorChangeInProgress = false;
}
if (TreeWalkHelper.HasChildren(fe, fce))
{
FrameworkContextData frameworkContextData = FrameworkContextData.From(dependencyObject.Dispatcher);
if (frameworkContextData.WasNodeVisited(dependencyObject, TreeWalkHelper.TreeChangeDelegate))
{
return;
}
TreeChangeInfo data = new TreeChangeInfo(dependencyObject, parent, isAddOperation);
PrePostDescendentsWalker <TreeChangeInfo> prePostDescendentsWalker = new PrePostDescendentsWalker <TreeChangeInfo>(TreeWalkPriority.LogicalTree, TreeWalkHelper.TreeChangeDelegate, TreeWalkHelper.TreeChangePostDelegate, data);
frameworkContextData.AddWalker(TreeWalkHelper.TreeChangeDelegate, prePostDescendentsWalker);
try
{
prePostDescendentsWalker.StartWalk(dependencyObject);
return;
}
finally
{
frameworkContextData.RemoveWalker(TreeWalkHelper.TreeChangeDelegate, prePostDescendentsWalker);
}
}
TreeChangeInfo info = new TreeChangeInfo(dependencyObject, parent, isAddOperation);
TreeWalkHelper.OnAncestorChanged(fe, fce, info);
bool visitedViaVisualTree = false;
TreeWalkHelper.OnPostAncestorChanged(dependencyObject, info, visitedViaVisualTree);
}
