private static void FindAllReferencedResources(DocumentNode node, List <DocumentNode> foundResources, Stack <DocumentNodePath> resourceReferenceTree, ResourceHelper.PostOrderOperation postOrderOperation)
{
foreach (DocumentNode documentNode1 in node.SelectDescendantNodes(new Predicate <DocumentNode>(ResourceHelper.FilterResources)))
{
DocumentNodePath context1 = new DocumentNodePath(node.DocumentRoot.RootNode, documentNode1);
resourceReferenceTree.Push(context1);
DocumentNode documentNode2 = (DocumentNode)null;
if (DocumentNodeUtilities.IsDynamicResource(documentNode1))
{
foreach (DocumentNodePath context2 in resourceReferenceTree)
{
documentNode2 = new ExpressionEvaluator((IDocumentRootResolver)context2.Node.Context).EvaluateExpression(context2, documentNode1);
if (documentNode2 != null)
{
break;
}
}
}
else
{
documentNode2 = new ExpressionEvaluator((IDocumentRootResolver)context1.Node.Context).EvaluateExpression(context1, documentNode1);
}
if (documentNode2 != null && !ResourceHelper.IsResourceCached(documentNode2, foundResources))
{
foundResources.Add(documentNode2);
ResourceHelper.FindAllReferencedResources(documentNode2, foundResources, resourceReferenceTree, postOrderOperation);
if (postOrderOperation != null)
{
postOrderOperation(documentNode2);
}
}
resourceReferenceTree.Pop();
}
}
public static string GetUserFriendlyDescription(DocumentCompositeNode expressionNode, DocumentNode parentNode)
{
if (DocumentNodeUtilities.IsDynamicResource((DocumentNode)expressionNode) || DocumentNodeUtilities.IsStaticResource((DocumentNode)expressionNode))
{
DocumentNode resourceKey = ResourceNodeHelper.GetResourceKey(expressionNode);
DocumentPrimitiveNode documentPrimitiveNode = resourceKey as DocumentPrimitiveNode;
DocumentCompositeNode expressionNode1 = resourceKey as DocumentCompositeNode;
if (documentPrimitiveNode != null && documentPrimitiveNode.Value != null)
{
return(documentPrimitiveNode.Value.ToString());
}
if (expressionNode1 != null && DocumentNodeUtilities.IsMarkupExtension((DocumentNode)expressionNode1))
{
return(XamlExpressionSerializer.GetUserFriendlyDescription(expressionNode1, (DocumentNode)expressionNode));
}
}
else if (DocumentNodeUtilities.IsStaticResource((DocumentNode)expressionNode))
{
DocumentPrimitiveNode documentPrimitiveNode = expressionNode.Properties[StaticExtensionProperties.MemberProperty] as DocumentPrimitiveNode;
if (documentPrimitiveNode != null)
{
return(documentPrimitiveNode.Value.ToString());
}
}
return(XamlExpressionSerializer.GetStringFromExpression((DocumentNode)expressionNode, parentNode));
}
private object InternalGetAmbientValue(ReferenceStep property, SceneNode targetNode)
{
AmbientPropertyManager.AmbientPropertyValue ambientPropertyValue = this.GetAmbientPropertyValue(property);
if (ambientPropertyValue != null)
{
if (ambientPropertyValue.Value == DependencyProperty.UnsetValue)
{
return(ambientPropertyValue.DefaultValue);
}
DocumentNode node = ambientPropertyValue.Value as DocumentNode;
if (node == null)
{
return(DependencyProperty.UnsetValue);
}
if (targetNode == null && (DocumentNodeUtilities.IsStaticResource(node) || DocumentNodeUtilities.IsDynamicResource(node) || DocumentNodeUtilities.IsTemplateBinding(node)))
{
return(ambientPropertyValue.DefaultValue);
}
DocumentCompositeNode documentCompositeNode = node as DocumentCompositeNode;
if (DocumentNodeUtilities.IsStaticResource(node) || DocumentNodeUtilities.IsDynamicResource(node))
{
DocumentNode resourceKey = ResourceNodeHelper.GetResourceKey(documentCompositeNode);
bool flag = new ExpressionEvaluator((IDocumentRootResolver)targetNode.ProjectContext).EvaluateResource(targetNode.DocumentNodePath, DocumentNodeUtilities.IsStaticResource(node) ? ResourceReferenceType.Static : ResourceReferenceType.Dynamic, resourceKey) != null;
if (!flag)
{
object instance = targetNode.ViewModel.CreateInstance(new DocumentNodePath(resourceKey, resourceKey));
if (instance != null)
{
flag = targetNode.ViewModel.FindResource(instance) != null;
}
}
if (!flag)
{
return(ambientPropertyValue.DefaultValue);
}
}
else if (DocumentNodeUtilities.IsTemplateBinding(node))
{
ExpressionEvaluator expressionEvaluator = new ExpressionEvaluator((IDocumentRootResolver)targetNode.ProjectContext);
if (documentCompositeNode == null || expressionEvaluator.EvaluateTemplateBinding(targetNode.DocumentNodePath, documentCompositeNode) == null)
{
return(ambientPropertyValue.DefaultValue);
}
}
return((object)node);
}
if (targetNode == null || !object.Equals(ambientPropertyValue.DefaultValue, targetNode.GetDefaultValueAsWpf((IPropertyId)property)))
{
return(ambientPropertyValue.DefaultValue);
}
return(DependencyProperty.UnsetValue);
}
private static void ReplaceTemplateTargetType(DocumentNode root, IList <DocumentCompositeNode> resources, IType targetType)
{
DocumentCompositeNode node = root as DocumentCompositeNode;
if (node == null)
{
return;
}
DocumentCompositeNode parent = root.Parent;
if (parent != null && PlatformTypes.Setter.IsAssignableFrom((ITypeId)parent.Type) && (parent.TypeResolver.ResolveProperty(SetterSceneNode.TargetNameProperty) == null || parent.Properties[SetterSceneNode.TargetNameProperty] == null) && (ControlStylingOperations.DoesPropertyAffectRoot((IPropertyId)root.GetValueProperty()) && parent.Properties[SetterSceneNode.ValueProperty] == root))
{
if (PlatformTypes.ControlTemplate.IsAssignableFrom((ITypeId)root.Type))
{
node.Properties[ControlTemplateElement.TargetTypeProperty] = (DocumentNode)node.Context.CreateNode(PlatformTypes.Type, (IDocumentNodeValue) new DocumentNodeMemberValue((IMember)targetType));
}
else if (DocumentNodeUtilities.IsDynamicResource(root) || DocumentNodeUtilities.IsStaticResource(root))
{
DocumentNode resourceKey = ResourceNodeHelper.GetResourceKey(node);
if (resourceKey != null && resources != null)
{
foreach (DocumentCompositeNode entryNode in (IEnumerable <DocumentCompositeNode>)resources)
{
if (resourceKey.Equals(ResourceNodeHelper.GetResourceEntryKey(entryNode)))
{
DocumentCompositeNode documentCompositeNode = entryNode.Properties[DictionaryEntryNode.ValueProperty] as DocumentCompositeNode;
if (documentCompositeNode != null)
{
if (PlatformTypes.ControlTemplate.IsAssignableFrom((ITypeId)documentCompositeNode.Type))
{
documentCompositeNode.Properties[ControlTemplateElement.TargetTypeProperty] = (DocumentNode)documentCompositeNode.Context.CreateNode(PlatformTypes.Type, (IDocumentNodeValue) new DocumentNodeMemberValue((IMember)targetType));
break;
}
break;
}
break;
}
}
}
}
}
if (parent != null && DocumentNodeUtilities.IsStyleOrTemplate(root.Type))
{
return;
}
foreach (DocumentNode root1 in node.ChildNodes)
{
ReplaceStyleTemplateCommand.ReplaceTemplateTargetType(root1, resources, targetType);
}
}
private IEnumerable <SceneNode> FilteredResourceEnumerator(SceneNode pivot)
{
if (DocumentNodeUtilities.IsStaticResource(pivot.DocumentNode) || DocumentNodeUtilities.IsDynamicResource(pivot.DocumentNode))
{
yield return(pivot);
}
else
{
DocumentNode parent = (DocumentNode)pivot.DocumentNode.Parent;
if (parent != null && parent.TargetType == typeof(DictionaryEntry))
{
yield return(pivot.ViewModel.GetSceneNode(parent));
}
}
}
internal static DocumentCompositeNode LookupResource(SceneViewModel viewModel, DocumentCompositeNode findMe)
{
DocumentNode resourceKey = ResourceNodeHelper.GetResourceKey(findMe);
if (resourceKey != null)
{
DocumentNode documentNode = new ExpressionEvaluator(viewModel.DocumentRootResolver).EvaluateResource(viewModel.GetSceneNode((DocumentNode)findMe).DocumentNodePath, DocumentNodeUtilities.IsDynamicResource((DocumentNode)findMe) ? ResourceReferenceType.Dynamic : ResourceReferenceType.Static, resourceKey);
if (documentNode != null)
{
return(documentNode.Parent);
}
}
return((DocumentCompositeNode)null);
}
public override void Execute()
{
PerformanceUtility.StartPerformanceSequence(PerformanceEvent.EditStyleOrTemplate);
if (this.IsEnabled)
{
SceneElement targetElement = this.TargetElement;
IDocumentContext documentContext = this.SceneViewModel.Document.DocumentContext;
Type propertyTargetType = this.SceneViewModel.Document.ProjectContext.MetadataFactory.GetMetadata(this.Type.RuntimeType).GetStylePropertyTargetType((IPropertyId)this.TargetProperty);
CreateResourceModel.ContextFlags contextFlags = !PlatformTypes.ControlTemplate.IsAssignableFrom((ITypeId)this.TargetProperty.PropertyType) ? (this.SceneViewModel.ProjectContext.IsCapabilitySet(PlatformCapability.SupportsImplicitStyles) ? CreateResourceModel.ContextFlags.CanApplyAutomatically : CreateResourceModel.ContextFlags.None) : CreateResourceModel.ContextFlags.None;
CreateResourceModel model = new CreateResourceModel(this.SceneViewModel, this.DesignerContext.ResourceManager, PlatformTypeHelper.GetPropertyType((IProperty)this.TargetProperty), propertyTargetType, this.TargetProperty.Name, (SceneElement)null, (SceneNode)(targetElement as BaseFrameworkElement), contextFlags);
IList <DocumentCompositeNode> auxillaryResources;
DocumentNode node1 = this.ProvideValue(out auxillaryResources);
if (node1 != null)
{
IPropertyId targetTypeProperty = this.GetTargetTypeProperty((ITypeId)this.TargetProperty.PropertyType);
DocumentCompositeNode documentCompositeNode = node1 as DocumentCompositeNode;
if (targetTypeProperty != null && documentCompositeNode != null)
{
IType valueAsType = DocumentPrimitiveNode.GetValueAsType(documentCompositeNode.Properties[targetTypeProperty]);
if (valueAsType != null && valueAsType.RuntimeType != (Type)null)
{
model.TargetType = valueAsType.RuntimeType;
}
}
else
{
model.TargetType = (Type)null;
}
ReplaceStyleTemplateCommand.ExtraReferences references = new ReplaceStyleTemplateCommand.ExtraReferences();
this.CollectExtraReferences(node1, references);
if (auxillaryResources != null)
{
foreach (DocumentNode node2 in (IEnumerable <DocumentCompositeNode>)auxillaryResources)
{
this.CollectExtraReferences(node2, references);
}
}
if (references.UnresolvedTypes.Count > 0)
{
string message = string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.CopyStyleTemplateTypesNotInDocumentMessage, new object[2]
{
(object)this.TargetProperty.Name,
(object)SceneView.GetUnresolvedTypesList(references.UnresolvedTypes)
});
if (!this.ShowUI)
{
return;
}
this.DesignerContext.MessageDisplayService.ShowError(message);
return;
}
if (this.ShowUI)
{
bool?nullable = new CreateResourceDialog(this.DesignerContext, model).ShowDialog();
if ((!nullable.GetValueOrDefault() ? 1 : (!nullable.HasValue ? true : false)) != 0)
{
return;
}
}
bool flag = model.CurrentResourceSite != null;
if (!flag || targetElement.DocumentNode.DocumentRoot == null)
{
return;
}
SceneViewModel viewModel = this.SceneViewModel.GetViewModel(model.CurrentResourceSite.HostNode.DocumentRoot, false);
if (viewModel == null || !PlatformTypes.PlatformsCompatible(node1.PlatformMetadata, viewModel.ProjectContext.PlatformMetadata) || !this.AddReferences(viewModel.ProjectContext, references, model.KeyString))
{
return;
}
using (SceneEditTransaction editTransaction1 = this.SceneViewModel.CreateEditTransaction(this.UndoString))
{
DocumentNode documentNode1 = (DocumentNode)null;
DocumentCompositeNode resource;
using (SceneEditTransaction editTransaction2 = viewModel.CreateEditTransaction(this.UndoString))
{
DocumentNode newResourceNode;
try
{
newResourceNode = node1.Clone(viewModel.Document.DocumentContext);
}
catch
{
editTransaction2.Cancel();
editTransaction1.Cancel();
this.DesignerContext.MessageDisplayService.ShowError(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.CommandFailedDialogMessage, new object[1]
{
(object)this.UndoString
}));
return;
}
newResourceNode.Name = (string)null;
bool useStaticResource = !(this.TargetProperty is DependencyPropertyReferenceStep) || !JoltHelper.TypeSupported((ITypeResolver)this.SceneViewModel.ProjectContext, PlatformTypes.DynamicResource);
int index = useStaticResource ? model.IndexInResourceSite(targetElement.DocumentNode) : -1;
resource = model.CreateResource(newResourceNode, targetTypeProperty, index);
flag = resource != null;
if (flag)
{
documentNode1 = model.CreateResourceReference(this.SceneViewModel.Document.DocumentContext, resource, useStaticResource);
flag = Microsoft.Expression.DesignSurface.Utility.ResourceHelper.CopyResourcesToNewResourceSite(auxillaryResources, viewModel, model.CurrentResourceSite.HostNode, resource, model.IndexInResourceSite((DocumentNode)resource));
}
if (flag)
{
editTransaction2.Commit();
if (this.SceneViewModel == viewModel)
{
editTransaction1.Update();
this.DesignerContext.ViewUpdateManager.UpdateRelatedViews(this.SceneViewModel.Document, false);
}
this.DesignerContext.ViewUpdateManager.RefreshActiveViewApplicationResources();
}
else
{
editTransaction2.Cancel();
}
}
if (flag && resource != null)
{
DocumentNode documentNode2 = resource.Properties[DictionaryEntryNode.ValueProperty];
DocumentNodePath documentNodePath;
if (targetElement.IsAttached)
{
if (documentNode1 != null)
{
targetElement.SetValue(this.TargetPropertyReference, (object)documentNode1);
}
else
{
targetElement.ClearValue(this.TargetPropertyReference);
}
this.SceneView.CandidateEditingContainer = targetElement.DocumentNodePath;
editTransaction1.Update();
this.SceneView.CandidateEditingContainer = (DocumentNodePath)null;
documentNodePath = this.ProvideEditingContainer(targetElement, this.TargetPropertyReference, documentNode2);
}
else
{
documentNodePath = (DocumentNodePath)null;
}
if (this.SceneView.IsValid)
{
if (documentNodePath != null && documentNodePath.Node != null && (!DocumentNodeUtilities.IsDynamicResource(documentNodePath.Node) && !DocumentNodeUtilities.IsStaticResource(documentNodePath.Node)))
{
DocumentNode node2 = documentNodePath.Node;
bool preferInPlaceEdit = ControlStylingOperations.CanEditInPlace(targetElement, this.TargetProperty, documentNodePath);
ControlStylingOperations.SetActiveEditingContainer(targetElement, this.TargetProperty, node2, documentNodePath, preferInPlaceEdit, editTransaction1);
}
else
{
ControlStylingOperations.SetActiveEditingContainer(targetElement, this.TargetProperty, documentNode2, (DocumentNodePath)null, false, editTransaction1);
}
}
editTransaction1.Commit();
}
else
{
editTransaction1.Cancel();
}
}
}
}
PerformanceUtility.EndPerformanceSequence(PerformanceEvent.EditStyleOrTemplate);
}
protected DocumentNode ProvideCurrentStyle(SceneElement targetElement, IType targetType, PropertyReference targetPropertyReference, bool allowDefaultStyle, out IList <DocumentCompositeNode> auxillaryResources)
{
auxillaryResources = (IList <DocumentCompositeNode>)null;
DocumentNode currentStyle = (DocumentNode)null;
bool isThemeStyle = false;
IType targetType1 = targetType;
if (!this.TargetProperty.Equals((object)BaseFrameworkElement.StyleProperty))
{
IDocumentContext documentContext = this.SceneViewModel.Document.DocumentContext;
Type propertyTargetType = this.SceneViewModel.Document.ProjectContext.MetadataFactory.GetMetadata(this.Type.RuntimeType).GetStylePropertyTargetType((IPropertyId)this.TargetProperty);
targetType1 = propertyTargetType == (Type)null ? (IType)null : this.SceneViewModel.ProjectContext.GetType(propertyTargetType);
}
if (targetElement.IsSet(targetPropertyReference) == PropertyState.Set)
{
DocumentNodePath valueAsDocumentNode = targetElement.GetLocalValueAsDocumentNode(targetPropertyReference);
if (valueAsDocumentNode != null && valueAsDocumentNode.Node is DocumentCompositeNode && PlatformTypes.Style.IsAssignableFrom((ITypeId)valueAsDocumentNode.Node.Type) && (!StyleNode.IsDefaultValue(valueAsDocumentNode.Node) || allowDefaultStyle))
{
StyleNode styleNode = targetElement.ClonePropertyValueAsSceneNode(targetPropertyReference) as StyleNode;
if (styleNode != null)
{
currentStyle = styleNode.DocumentNode;
auxillaryResources = Microsoft.Expression.DesignSurface.Utility.ResourceHelper.FindReferencedResources(valueAsDocumentNode.Node);
}
}
}
if (currentStyle == null)
{
object obj = this.ResolveCurrentStyle(targetElement, targetPropertyReference, allowDefaultStyle);
if (obj != null)
{
DocumentNode correspondingDocumentNode = this.SceneView.GetCorrespondingDocumentNode(this.SceneViewModel.ProjectContext.Platform.ViewObjectFactory.Instantiate(obj), true);
if (correspondingDocumentNode != null && PlatformTypes.Style.IsAssignableFrom((ITypeId)correspondingDocumentNode.Type))
{
currentStyle = correspondingDocumentNode;
}
else if (obj is Style)
{
StyleNode styleNode = (StyleNode)this.SceneViewModel.CreateSceneNode(obj);
if (targetType1 != null)
{
styleNode.StyleTargetTypeId = targetType1;
}
currentStyle = styleNode.DocumentNode;
}
}
if (currentStyle != null && !allowDefaultStyle && StyleNode.IsDefaultValue(currentStyle))
{
currentStyle = (DocumentNode)null;
}
}
if (currentStyle == null)
{
object defaultStyleKey = this.GetDefaultStyleKey(targetElement, (ITypeId)targetType1, (IPropertyId)this.TargetProperty);
if (defaultStyleKey != null)
{
this.ResolveDefaultStyle(targetElement, defaultStyleKey, allowDefaultStyle, out currentStyle, out isThemeStyle, out auxillaryResources);
}
}
if (currentStyle != null && !allowDefaultStyle)
{
List <DocumentCompositeNode> list = new List <DocumentCompositeNode>();
DocumentCompositeNode node = currentStyle as DocumentCompositeNode;
IProperty property = this.SceneViewModel.ProjectContext.ResolveProperty(StyleNode.BasedOnProperty);
while (node != null && property != null && (node.Type.Equals((object)PlatformTypes.Style) && node.Properties.Count == 2) && (node.Properties[(IPropertyId)property] != null && node.Properties[StyleNode.TargetTypeProperty] != null))
{
node = node.Properties[StyleNode.BasedOnProperty] as DocumentCompositeNode;
if (node != null)
{
if (DocumentNodeUtilities.IsDynamicResource((DocumentNode)node) || DocumentNodeUtilities.IsStaticResource((DocumentNode)node))
{
DocumentNode resourceKey = ResourceNodeHelper.GetResourceKey(node);
if (resourceKey != null && auxillaryResources != null)
{
foreach (DocumentCompositeNode entryNode in (IEnumerable <DocumentCompositeNode>)auxillaryResources)
{
if (resourceKey.Equals(ResourceNodeHelper.GetResourceEntryKey(entryNode)))
{
node = entryNode.Properties[DictionaryEntryNode.ValueProperty] as DocumentCompositeNode;
break;
}
}
}
}
if (PlatformTypes.Style.IsAssignableFrom((ITypeId)node.Type))
{
currentStyle = (DocumentNode)node;
list.Add(node);
}
}
}
if (auxillaryResources != null)
{
foreach (DocumentNode documentNode in list)
{
DocumentCompositeNode parent = documentNode.Parent;
if (parent != null && parent.Type.Equals((object)PlatformTypes.DictionaryEntry))
{
auxillaryResources.Remove(parent);
}
}
}
if (currentStyle != null && (list.Count > 0 || currentStyle.DocumentRoot != null))
{
currentStyle = currentStyle.Clone(targetElement.DocumentContext);
}
if (auxillaryResources != null)
{
for (int index = 0; index < auxillaryResources.Count; ++index)
{
if (auxillaryResources[index].DocumentRoot != null)
{
auxillaryResources[index] = (DocumentCompositeNode)auxillaryResources[index].Clone(targetElement.DocumentContext);
}
}
}
if (isThemeStyle)
{
ReplaceStyleTemplateCommand.StripFormatting(currentStyle);
if (auxillaryResources != null)
{
for (int index = 0; index < auxillaryResources.Count; ++index)
{
ReplaceStyleTemplateCommand.StripFormatting((DocumentNode)auxillaryResources[index]);
}
}
}
DocumentCompositeNode documentCompositeNode = currentStyle as DocumentCompositeNode;
if (documentCompositeNode != null && targetType1 != null)
{
documentCompositeNode.Properties[StyleNode.TargetTypeProperty] = (DocumentNode)documentCompositeNode.Context.CreateNode(PlatformTypes.Type, (IDocumentNodeValue) new DocumentNodeMemberValue((IMember)targetType1));
}
if (targetType1 != null)
{
ReplaceStyleTemplateCommand.ReplaceTemplateTargetType(currentStyle, auxillaryResources, targetType1);
}
}
return(currentStyle);
}