public static DocumentCompositeNode FindResource(DocumentNode key, DocumentCompositeNode resourcesCollection, int numberOfChildrenToSearch) { if (resourcesCollection != null && resourcesCollection.SupportsChildren) { IList <DocumentNode> children = resourcesCollection.Children; if (numberOfChildrenToSearch < 0) { numberOfChildrenToSearch = children.Count; } for (int i = 0; i < numberOfChildrenToSearch; i++) { DocumentCompositeNode item = children[i] as DocumentCompositeNode; if (item != null) { DocumentNode resourceEntryKey = ResourceNodeHelper.GetResourceEntryKey(item); if (resourceEntryKey == null) { DocumentCompositeNode documentCompositeNode = item.Properties[KnownProperties.DictionaryEntryValueProperty] as DocumentCompositeNode; if (documentCompositeNode != null) { resourceEntryKey = ResourceSite.GetImplicitKey(documentCompositeNode); } } if (resourceEntryKey != null && resourceEntryKey.Equals(key)) { return(item); } } } } return(null); }
public static bool CompareTriggerNodes(DocumentCompositeNode triggerNode1, DocumentCompositeNode triggerNode2) { IProperty propertyKey = triggerNode1.TypeResolver.ResolveProperty(BehaviorTriggerBaseNode.BehaviorActionsProperty); bool flag = false; int num1 = 0; if (triggerNode1.Properties.Count <= triggerNode2.Properties.Count) { flag = true; foreach (KeyValuePair <IProperty, DocumentNode> keyValuePair in (IEnumerable <KeyValuePair <IProperty, DocumentNode> >)triggerNode2.Properties) { IProperty key = keyValuePair.Key; DocumentNode documentNode = triggerNode1.Properties[(IPropertyId)key]; if (!key.Equals((object)propertyKey)) { if (documentNode == null || !documentNode.Equals(keyValuePair.Value)) { flag = false; break; } ++num1; } } } if (!flag) { return(false); } int num2 = triggerNode1.Properties.Contains(propertyKey) ? triggerNode1.Properties.Count - 1 : triggerNode1.Properties.Count; return(num1 == num2); }
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 static void ChangeKey(IList <SceneNode> elements, DictionaryEntryNode resource, DocumentNode oldKey, DocumentNode newKey) { resource.KeyNode = resource.ViewModel.GetSceneNode(newKey); if (elements == null) { return; } foreach (SceneNode sceneNode in (IEnumerable <SceneNode>)elements) { foreach (DocumentNode expression in sceneNode.DocumentNode.SelectDescendantNodes(new Predicate <DocumentNode>(ResourceHelper.FilterResources))) { DocumentCompositeNode node = expression as DocumentCompositeNode; if (node != null) { DocumentNode resourceKey = ResourceNodeHelper.GetResourceKey(node); if (resourceKey != null && resourceKey.Equals(oldKey) && new ExpressionEvaluator((IDocumentRootResolver)null).EvaluateExpression(sceneNode.DocumentNodePath, expression) == null) { ResourceNodeHelper.SetResourceKey(node, newKey.Clone(sceneNode.DocumentContext)); } } } } }
public override DocumentNode GetLocalValueAsDocumentNode(SceneNodeProperty property, GetLocalValueFlags flags, out bool isMixed) { DocumentNode documentNode = (DocumentNode)null; bool flag = false; foreach (SceneNode sceneNode1 in this.Objects) { PropertyReference propertyReference1 = SceneNodeObjectSet.FilterProperty(sceneNode1, property.Reference); if (propertyReference1 != null) { DocumentNode other = (DocumentNode)null; if ((flags & GetLocalValueFlags.CheckKeyframes) != GetLocalValueFlags.None && sceneNode1.ViewModel.AnimationEditor.ActiveStoryboardTimeline != null && this.ShouldAllowAnimation) { SceneNode ancestor = (SceneNode)null; PropertyReference propertyReference2 = propertyReference1; SceneNode sceneNode2 = sceneNode1; if (this.FindAncestor(sceneNode1, out ancestor, ref propertyReference2, new Predicate <SceneNode>(SceneNodeObjectSetBase.IsAnimationParent))) { sceneNode2 = ancestor; } foreach (TimelineSceneNode timelineSceneNode in (IEnumerable <TimelineSceneNode>)sceneNode1.ViewModel.AnimationEditor.ActiveStoryboardTimeline.Children) { TimelineSceneNode.PropertyNodePair elementAndProperty = timelineSceneNode.TargetElementAndProperty; if (elementAndProperty.SceneNode == sceneNode2 && elementAndProperty.PropertyReference != null) { PropertyReference propertyReference3 = SceneNodeObjectSet.FilterProperty(elementAndProperty.SceneNode, elementAndProperty.PropertyReference); if (propertyReference2.Equals((object)propertyReference3)) { KeyFrameAnimationSceneNode animationSceneNode1 = timelineSceneNode as KeyFrameAnimationSceneNode; FromToAnimationSceneNode animationSceneNode2 = timelineSceneNode as FromToAnimationSceneNode; if (animationSceneNode1 != null) { KeyFrameSceneNode keyFrameAtTime = animationSceneNode1.GetKeyFrameAtTime(sceneNode1.ViewModel.AnimationEditor.AnimationTime); if (keyFrameAtTime != null) { using ((flags & GetLocalValueFlags.Resolve) == GetLocalValueFlags.None ? this.ViewModel.ForceBaseValue() : (IDisposable)null) { other = keyFrameAtTime.ValueNode; break; } } else { break; } } else if (animationSceneNode2 != null) { double animationTime = sceneNode1.ViewModel.AnimationEditor.AnimationTime; using ((flags & GetLocalValueFlags.Resolve) == GetLocalValueFlags.None ? this.ViewModel.ForceBaseValue() : (IDisposable)null) { DocumentNodePath documentNodePath = (DocumentNodePath)null; if (animationTime == animationSceneNode2.Begin + animationSceneNode2.Duration) { documentNodePath = animationSceneNode2.GetLocalValueAsDocumentNode(animationSceneNode2.ToProperty); } else if (animationTime == animationSceneNode2.Begin) { documentNodePath = animationSceneNode2.GetLocalValueAsDocumentNode(animationSceneNode2.FromProperty); } other = documentNodePath != null ? documentNodePath.Node : (DocumentNode)null; break; } } else { break; } } } } } if (other == null) { if ((flags & GetLocalValueFlags.Resolve) != GetLocalValueFlags.None) { DocumentNodePath valueAsDocumentNode = sceneNode1.GetLocalValueAsDocumentNode(propertyReference1); if (valueAsDocumentNode != null) { other = valueAsDocumentNode.Node; } } else { other = (DocumentNode)sceneNode1.GetLocalValue(propertyReference1, PropertyContext.AsDocumentNodes); } } if (!flag) { if (other == null && (flags & GetLocalValueFlags.SkipCheckIfMixed) != GetLocalValueFlags.None) { isMixed = false; return((DocumentNode)null); } flag = true; documentNode = other; } else if (documentNode == null && other != null || documentNode != null && !documentNode.Equals(other)) { isMixed = true; return((DocumentNode)null); } } } isMixed = false; return(documentNode); }
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); }