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)); }
protected bool DoesStyleOrTemplateApply(IPropertyId styleOrTemplateProperty, DocumentNode value) { if (PlatformTypes.FrameworkElement.IsAssignableFrom((ITypeId)this.Type)) { IType templateTargetType1 = DocumentNodeUtilities.GetStyleOrTemplateTargetType(value); Type type = templateTargetType1 != null ? templateTargetType1.RuntimeType : (Type)null; Type c = this.TargetElement.ProjectContext.MetadataFactory.GetMetadata(this.Type.RuntimeType).GetStylePropertyTargetType(styleOrTemplateProperty); if (type == (Type)null) { return(true); } if (StyleNode.BasedOnProperty.Equals((object)styleOrTemplateProperty)) { StyleNode styleNode = this.TargetElement as StyleNode; if (styleNode != null) { IType templateTargetType2 = DocumentNodeUtilities.GetStyleOrTemplateTargetType(styleNode.DocumentNode); c = templateTargetType2 != null ? templateTargetType2.RuntimeType : (Type)null; } } if (c == (Type)null && ControlStylingOperations.DoesPropertyAffectRoot((IPropertyId)this.TargetProperty)) { c = this.Type.RuntimeType; } if (c != (Type)null && !type.IsAssignableFrom(c)) { return(false); } } return(true); }
public override bool Instantiate(IInstanceBuilderContext context, ViewNode viewNode) { TemplateBindingInstanceBuilderBase.CheckForInvalidBinding(viewNode); bool flag = base.Instantiate(context, viewNode); if (context.RootTargetTypeReplacement != null && context.IsSerializationScope) { ViewNode viewNode1 = StyleControlTemplateHelper.FindContainingControlTemplate(viewNode); if (viewNode1 != null) { ViewNode viewNode2 = StyleControlTemplateHelper.FindStyleTemplateOwningViewNode(viewNode1); if (viewNode2 == null || viewNode2 == context.ViewNodeManager.Root) { DocumentCompositeNode documentNode = viewNode.DocumentNode as DocumentCompositeNode; if (documentNode != null && DocumentNodeUtilities.IsTemplateBinding(documentNode)) { IMemberId valueAsMember = DocumentNodeHelper.GetValueAsMember(documentNode, KnownProperties.TemplateBindingPropertyProperty); if (valueAsMember != null) { IProperty replacementProperty = context.RootTargetTypeReplacement.GetReplacementProperty(valueAsMember as IProperty); if (replacementProperty != null && replacementProperty is DependencyPropertyReferenceStep && replacementProperty != valueAsMember) { DocumentCompositeNode instance = (DocumentCompositeNode)viewNode.Instance; instance.Properties[KnownProperties.TemplateBindingPropertyProperty] = context.DocumentContext.CreateNode(PlatformTypes.DependencyProperty, new DocumentNodeMemberValue(replacementProperty)); } } } } } } return(flag); }
public static bool DoesPropertyApply(SceneNode sceneNode, ReferenceStep referenceStep, SceneNode valueNode, out ReferenceStep appliedReferenceStep) { appliedReferenceStep = sceneNode.DesignerContext.PropertyManager.FilterProperty(sceneNode, referenceStep); if (appliedReferenceStep == null) { return(false); } if (DocumentNodeUtilities.IsStyleOrTemplate(appliedReferenceStep.PropertyType)) { DocumentNode node = valueNode.DocumentNode; if (node.Type.IsExpression) { node = new ExpressionEvaluator(sceneNode.ViewModel.DocumentRootResolver).EvaluateExpression(sceneNode.DocumentNodePath, valueNode.DocumentNode); } if (node == null || !DocumentNodeUtilities.IsStyleOrTemplate(node.Type) || !appliedReferenceStep.PropertyType.IsAssignableFrom((ITypeId)node.Type)) { return(false); } IType templateTargetType = DocumentNodeUtilities.GetStyleOrTemplateTargetType(node); Type propertyTargetType = sceneNode.Metadata.GetStylePropertyTargetType((IPropertyId)appliedReferenceStep); if (templateTargetType != null && propertyTargetType != (Type)null && !templateTargetType.RuntimeType.IsAssignableFrom(propertyTargetType)) { return(false); } } return(true); }
public override SceneNode GenerateConverter() { IDocumentContext documentContext = this.valueConverter.DocumentContext; DocumentNode keyNode = (DocumentNode)documentContext.CreateNode(this.DisplayName); return(this.valueConverter.ViewModel.GetSceneNode((DocumentNode)DocumentNodeUtilities.NewStaticResourceNode(documentContext, keyNode))); }
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(); } }
private static void CheckForInvalidBinding(ViewNode viewNode) { if (viewNode == null || viewNode.DocumentNode == null || viewNode.DocumentNode.Parent == null || !viewNode.DocumentNode.IsProperty) { return; } IProperty sitePropertyKey = viewNode.DocumentNode.SitePropertyKey; if (KnownProperties.ContentControlContentProperty.Equals(sitePropertyKey) || KnownProperties.ContentPresenterContentProperty.Equals(sitePropertyKey)) { DocumentCompositeNode documentNode = (DocumentCompositeNode)viewNode.DocumentNode; if (DocumentNodeUtilities.IsBinding(documentNode)) { DocumentNode item = documentNode.Properties[KnownProperties.BindingPathProperty]; DocumentNode item1 = documentNode.Properties[KnownProperties.BindingRelativeSourceProperty]; DocumentNode documentNode1 = documentNode.Properties[KnownProperties.BindingElementNameProperty]; if (item == null && (item1 != null || documentNode1 != null)) { CultureInfo currentCulture = CultureInfo.CurrentCulture; string invalidBindingToVisualTreeElement = ExceptionStringTable.InvalidBindingToVisualTreeElement; object[] name = new object[] { sitePropertyKey.Name }; throw new InvalidOperationException(string.Format(currentCulture, invalidBindingToVisualTreeElement, name)); } } } }
protected virtual bool IsValueValidForVerification(DocumentNode valueNode) { if (!DocumentNodeUtilities.IsBinding(valueNode) && !DocumentNodeUtilities.IsTemplateBinding(valueNode)) { return(!DocumentNodeUtilities.IsStaticExtension(valueNode)); } return(false); }
protected DocumentNode GetReferentialPropertyValueAsDocumentNode(DocumentCompositeNode compositeNode) { DocumentNode documentNode = compositeNode.Properties[this.ReferentialProperty]; if (documentNode != null && DocumentNodeUtilities.IsResource(documentNode)) { documentNode = ExpressionEvaluator.EvaluateExpression(documentNode); } return(documentNode); }
public static DocumentNode FindTargetElement(DocumentNode node, bool resolveTargetName) { DocumentCompositeNode documentCompositeNode1 = node as DocumentCompositeNode; if (documentCompositeNode1 != null) { DocumentNode documentNode1 = documentCompositeNode1.Properties[BehaviorTargetedTriggerActionNode.BehaviorTargetNameProperty]; string elementName = !resolveTargetName || documentNode1 == null || !DocumentNodeUtilities.IsResource(documentNode1) ? documentCompositeNode1.GetValueAsString(BehaviorTargetedTriggerActionNode.BehaviorTargetNameProperty) : DocumentPrimitiveNode.GetValueAsString(ExpressionEvaluator.EvaluateExpression(documentNode1)); IProperty property1 = node.PlatformMetadata.ResolveProperty(BehaviorTargetedTriggerActionNode.BehaviorTargetObjectProperty); if (property1 != null) { DocumentNode documentNode2 = documentCompositeNode1.Properties[(IPropertyId)property1]; if (documentNode2 != null) { if (DocumentNodeUtilities.IsMarkupExtension(documentNode2)) { if (!DocumentNodeUtilities.IsBinding(documentNode2) || !GoToStateActionNode.CanResolveTargetFromBinding(documentNode2)) { return(ExpressionEvaluator.EvaluateExpression(documentNode2)); } documentNode2 = GoToStateActionNode.ResolveTargetFromBinding(node, (DocumentCompositeNode)documentNode2); } return(documentNode2); } } if (!string.IsNullOrEmpty(elementName)) { return(BehaviorHelper.FindNamedElement(node, elementName)); } DocumentNode documentNode3; for (documentNode3 = (DocumentNode)documentCompositeNode1; documentNode3 != null; documentNode3 = (DocumentNode)documentNode3.Parent) { DocumentCompositeNode documentCompositeNode2 = documentNode3 as DocumentCompositeNode; IProperty property2 = node.TypeResolver.ResolveProperty(VisualStateManagerSceneNode.VisualStateGroupsProperty); if (property2 == null) { return((DocumentNode)null); } if (documentCompositeNode2 != null && documentCompositeNode2.Properties[(IPropertyId)property2] != null) { break; } } if (documentNode3 != null) { DocumentCompositeNode parent = documentNode3.Parent; if (parent != null && PlatformTypes.ICollection.IsAssignableFrom((ITypeId)parent.Type) && parent.Parent != null) { return((DocumentNode)parent.Parent); } return((DocumentNode)documentNode3.Parent); } } return((DocumentNode)null); }
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); }
public override void SetValueToTemplateBinding(SceneNodeProperty propertyKey, ReferenceStep referenceStep) { SceneViewModel viewModel = this.ViewModel; if (viewModel == null) { return; } DocumentNode documentNode = (DocumentNode)DocumentNodeUtilities.NewTemplateBindingNode(this.RepresentativeNode, (IPropertyId)referenceStep, propertyKey.Reference); using (viewModel.AnimationEditor.DeferKeyFraming()) this.SetValue((PropertyReferenceProperty)propertyKey, (object)documentNode); }
public static bool CanResolveTargetFromBinding(DocumentNode node) { if (node == null || !DocumentNodeUtilities.IsBinding(node)) { return(false); } DocumentCompositeNode documentCompositeNode = (DocumentCompositeNode)node; if (documentCompositeNode.Properties[BindingSceneNode.ElementNameProperty] != null) { return(documentCompositeNode.Properties[BindingSceneNode.PathProperty] == null); } return(false); }
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)); } } }
public DocumentNode CreateResourceReference(IDocumentContext documentContext, DocumentCompositeNode resourceNode, bool useStaticResource) { DocumentNode resourceEntryKey = ResourceNodeHelper.GetResourceEntryKey(resourceNode); if (resourceEntryKey == null) { return((DocumentNode)null); } DocumentNode keyNode = resourceEntryKey.Clone(documentContext); if (useStaticResource) { return((DocumentNode)DocumentNodeUtilities.NewStaticResourceNode(documentContext, keyNode)); } return((DocumentNode)DocumentNodeUtilities.NewDynamicResourceNode(documentContext, keyNode)); }
protected bool BindsTwoWayByDefault(SceneNode targetNode, ReferenceStep targetProperty) { DependencyPropertyReferenceStep propertyReferenceStep = targetProperty as DependencyPropertyReferenceStep; if (propertyReferenceStep == null) { return(false); } Type targetType = targetNode.TargetType; if (DocumentNodeUtilities.IsStyleOrTemplate(targetNode.Type)) { targetType = DocumentNodeUtilities.GetStyleOrTemplateTargetType(targetNode.DocumentNode).RuntimeType; } return(propertyReferenceStep.BindsTwoWayByDefault(targetType)); }
private BindingSceneNode CreateFallbackBind(SceneViewModel viewModel, string bindingPath, SceneNode targetNode, IProperty targetProperty) { BindingSceneNode binding = BindingSceneNode.Factory.Instantiate(viewModel); if (this.ResourceKey != null) { DocumentNode keyNode = this.ResourceKey.Clone(viewModel.Document.DocumentContext); binding.Source = (DocumentNode)DocumentNodeUtilities.NewStaticResourceNode(viewModel.Document.DocumentContext, keyNode); } if (bindingPath.Length > 0) { binding.XPath = bindingPath; } using (targetNode.ViewModel.AnimationEditor.DeferKeyFraming()) targetNode.SetBinding((IPropertyId)targetProperty, binding); return(binding); }
public override bool Instantiate(IInstanceBuilderContext context, ViewNode viewNode) { IPropertyId sitePropertyKey; DocumentPrimitiveNode documentNode = viewNode.DocumentNode as DocumentPrimitiveNode; if (documentNode != null) { DocumentNodeStringValue value = documentNode.Value as DocumentNodeStringValue; if (value != null) { if (viewNode.Parent == null || !viewNode.IsProperty) { sitePropertyKey = null; } else { sitePropertyKey = viewNode.SitePropertyKey; } IPropertyId propertyProperty = sitePropertyKey; if (viewNode.Parent != null) { IPropertyValueTypeMetadata metadata = viewNode.Parent.DocumentNode.Type.Metadata as IPropertyValueTypeMetadata; IPropertyValueTypeMetadata propertyValueTypeMetadatum = metadata; if (metadata != null) { propertyProperty = propertyValueTypeMetadatum.PropertyProperty; } } if (this.ShouldUseDesignTimeUri(propertyProperty)) { Uri uri = new Uri(value.Value, UriKind.RelativeOrAbsolute); Uri uri1 = viewNode.DocumentNode.Context.MakeDesignTimeUri(uri); if (!context.IsSerializationScope) { viewNode.Instance = uri1; } else { viewNode.Instance = DocumentNodeUtilities.NewUriDocumentNode(context.DocumentContext, uri1); } viewNode.InstanceState = InstanceState.Valid; } } } return(base.Instantiate(context, viewNode)); }
private bool HasValidValue(SceneViewModel viewModel, DocumentNodePath documentNodePath) { if (documentNodePath != null && !DocumentNodeUtilities.IsBinding(documentNodePath.Node)) { SceneView activeView = viewModel.DesignerContext.ActiveView; if (activeView != null) { IInstanceBuilderContext instanceBuilderContext = activeView.InstanceBuilderContext; IExceptionDictionary exceptionDictionary = instanceBuilderContext.ExceptionDictionary; ViewNode viewNode; if (instanceBuilderContext.ViewNodeManager.TryGetCorrespondingViewNode(documentNodePath, out viewNode)) { return(!exceptionDictionary.Contains(viewNode)); } return(true); } } return(false); }
public override void SetValueToLocalResource(SceneNodeProperty propertyKey, LocalResourceModel localResource) { DocumentNode resourceKey = localResource.ResourceKey; PerformanceUtility.StartPerformanceSequence(PerformanceEvent.ApplyResource, "Apply resource."); SceneViewModel viewModel = this.ViewModel; if (viewModel != null) { IDocumentContext documentContext = viewModel.Document.DocumentContext; IProjectContext projectContext = viewModel.ProjectContext; DocumentNode keyNode = resourceKey.Clone(documentContext); bool flag = this.CanSetDynamicExpression && JoltHelper.TypeSupported((ITypeResolver)projectContext, PlatformTypes.DynamicResource); if (flag && this.ShouldAllowAnimation && (propertyKey.IsEnabledRecordCurrentValue && this.ViewModel.AnimationEditor.IsRecording)) { flag = false; } DocumentNode documentNode = !flag ? (DocumentNode)DocumentNodeUtilities.NewStaticResourceNode(documentContext, keyNode) : (DocumentNode)DocumentNodeUtilities.NewDynamicResourceNode(documentContext, keyNode); using (this.ShouldAllowAnimation ? (IDisposable)null : viewModel.AnimationEditor.DeferKeyFraming()) { string description = string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.PropertyChangeUndoDescription, new object[1] { (object)((PropertyEntry)propertyKey).get_PropertyName() }); if (viewModel.Document.IsEditable) { using (SceneEditTransaction editTransaction = viewModel.CreateEditTransaction(description)) { this.SetValue((PropertyReferenceProperty)propertyKey, (object)documentNode); bool isMixed; DocumentNode valueAsDocumentNode = this.GetLocalValueAsDocumentNode(propertyKey, GetLocalValueFlags.CheckKeyframes, out isMixed); if (!isMixed && valueAsDocumentNode != null) { Microsoft.Expression.DesignSurface.Utility.ResourceHelper.EnsureReferencedResourcesAreReachable(localResource.ResourceNode, valueAsDocumentNode); } editTransaction.Commit(); } } } } PerformanceUtility.EndPerformanceSequence(PerformanceEvent.ApplyResource, "Apply resource."); }
public List <ViewNode> GetExpressionValue(DocumentNode target) { List <ViewNode> viewNodes; List <ViewNode> viewNodes1 = new List <ViewNode>(); List <ViewNode> viewNodes2 = null; if (base.TryGetValue(target, out viewNodes)) { foreach (ViewNode viewNode in viewNodes) { if (viewNode.Parent != null) { if (DocumentNodeUtilities.IsBinding(target)) { continue; } viewNodes1.Add(viewNode); } else { if (viewNodes2 == null) { viewNodes2 = new List <ViewNode>(); } viewNodes2.Add(viewNode); } } if (viewNodes2 != null) { if (viewNodes2.Count != viewNodes.Count) { this.PurgePartialEntry(viewNodes, viewNodes2); } else { base.Remove(target); } } } return(viewNodes1); }
public override bool Verify(DocumentNode node) { DocumentCompositeNode compositeNode = node as DocumentCompositeNode; if (this.builder == null) { this.builder = new StateNameBuilder(this.designerContext); this.builder.Begin(); } if (compositeNode != null) { string referentialPropertyValue = this.GetReferentialPropertyValue(compositeNode); DocumentNode targetElement = GoToStateActionNode.FindTargetElement(node, true); List <string> results; if (targetElement != null && (DocumentNodeUtilities.IsBinding(targetElement) && !GoToStateActionNode.CanResolveTargetFromBinding(targetElement) || Enumerable.Contains <string>(this.builder.GetStateNamesForNode(targetElement), referentialPropertyValue) || PlatformNeutralAttributeHelper.TryGetAttributeValues <string>((IEnumerable)TypeUtilities.GetAttributes(targetElement.TargetType), ProjectNeutralTypes.TemplateVisualStateAttribute, "Name", out results) && results.Contains(referentialPropertyValue))) { return(true); } } return(false); }
private void AddProperties(SceneElement targetElement, ResourceEntryItem resource, System.Windows.Controls.ItemCollection menuItems) { Type filterType = (Type)null; bool flag = true; if (PlatformTypes.Brush.IsAssignableFrom((ITypeId)resource.Resource.Type)) { filterType = typeof(Brush); } else if (PlatformTypes.DrawingImage.IsAssignableFrom((ITypeId)resource.Resource.Type)) { filterType = typeof(ImageSource); } else if (PlatformTypes.PlatformsCompatible(resource.Resource.ValueNode.Type.PlatformMetadata, targetElement.Type.PlatformMetadata)) { IType styleOrTemplateType; ITypeId typeAndTargetType = DocumentNodeUtilities.GetStyleOrTemplateTypeAndTargetType(resource.Resource.ValueNode, out styleOrTemplateType); if (typeAndTargetType != null) { flag = typeAndTargetType.IsAssignableFrom((ITypeId)targetElement.Type); filterType = styleOrTemplateType.RuntimeType; } } else { flag = false; } if (!flag) { return; } int count = menuItems.Count; this.AddElementPropertiesWithTypeFilter(targetElement, resource, menuItems, filterType); if (menuItems.Count != count) { return; } this.AddElementPropertiesWithTypeFilter(targetElement, resource, menuItems, (Type)null); }
public override void SetValueToSystemResource(SceneNodeProperty propertyKey, SystemResourceModel systemResource) { PerformanceUtility.StartPerformanceSequence(PerformanceEvent.ApplyResource, "Apply system resource."); SceneViewModel viewModel = this.ViewModel; if (viewModel != null) { IDocumentContext documentContext = viewModel.Document.DocumentContext; IType type = viewModel.ProjectContext.ProjectNamespaces.GetType((IXmlNamespace)XmlNamespace.AvalonXmlNamespace, systemResource.CollectionName); if (type != null) { IMember memberId = (IMember)type.GetMember(MemberType.LocalProperty | MemberType.Field, systemResource.ResourceName, MemberAccessTypes.Public); DocumentNode documentNode = (DocumentNode)null; if (memberId != null) { documentNode = (DocumentNode)DocumentNodeUtilities.NewDynamicResourceNode(documentContext, (DocumentNode)DocumentNodeUtilities.NewStaticNode(documentContext, memberId)); } using (this.ShouldAllowAnimation ? (IDisposable)null : viewModel.AnimationEditor.DeferKeyFraming()) this.SetValue((PropertyReferenceProperty)propertyKey, (object)documentNode); } } PerformanceUtility.EndPerformanceSequence(PerformanceEvent.ApplyResource, "Apply resource."); }
public override bool Verify(DocumentNode node) { DocumentCompositeNode compositeNode = node as DocumentCompositeNode; if (compositeNode != null) { if (DocumentNodeUtilities.IsBinding(node)) { return(true); } string referentialPropertyValue = this.GetReferentialPropertyValue(compositeNode); if (string.IsNullOrEmpty(referentialPropertyValue)) { return(this.allowNullOrEmpty); } IPrototypingService prototypingService = this.designerContext.PrototypingService; if (prototypingService != null && prototypingService.ScreenExists(referentialPropertyValue)) { return(true); } } return(false); }
private SceneNode CreateDataSource(SceneNode target, DataSchemaNodePath bindingPath, bool isSourcePathLess) { DocumentNode resourceKey = bindingPath.Schema.DataSource.ResourceKey; if (resourceKey == null) { if (!isSourcePathLess && !string.IsNullOrEmpty(bindingPath.Path)) { return((SceneNode)null); } DocumentNode documentNode = bindingPath.Schema.DataSource.DocumentNode; IProjectItem designDataFile = DesignDataHelper.GetDesignDataFile(documentNode); DocumentNode node; if (designDataFile != null) { node = DesignDataHelper.CreateDesignDataExtension(designDataFile, target.DocumentContext); } else { if (PlatformTypes.FrameworkElement.IsAssignableFrom((ITypeId)bindingPath.Schema.DataSource.DocumentNode.Type)) { return((SceneNode)null); } node = documentNode.Clone(target.DocumentContext); } return(target.ViewModel.GetSceneNode(node)); } if (!this.EnsureDataSourceReachable(target, bindingPath.Schema.DataSource)) { return((SceneNode)null); } BindingSceneNode bindingSceneNode = BindingSceneNode.Factory.Instantiate(target.ViewModel); DocumentNode keyNode = resourceKey.Clone(target.DocumentContext); bindingSceneNode.Source = (DocumentNode)DocumentNodeUtilities.NewStaticResourceNode(keyNode.Context, keyNode); return((SceneNode)bindingSceneNode); }
public static void PrepareContentPresenter(ContentPresenterElement element) { IDocumentContext documentContext = element.DocumentContext; element.SetLocalValue(BaseFrameworkElement.HorizontalAlignmentProperty, (DocumentNode)DocumentNodeUtilities.NewTemplateBindingNode(element.DocumentNode, ControlElement.HorizontalContentAlignmentProperty)); element.SetLocalValue(BaseFrameworkElement.VerticalAlignmentProperty, (DocumentNode)DocumentNodeUtilities.NewTemplateBindingNode(element.DocumentNode, ControlElement.VerticalContentAlignmentProperty)); if (element.IsSnapsToDevicePixelsSupported) { element.SetLocalValue(Base2DElement.SnapsToDevicePixelsProperty, (DocumentNode)DocumentNodeUtilities.NewTemplateBindingNode(element.DocumentNode, Base2DElement.SnapsToDevicePixelsProperty)); } if (!element.IsRecognizesAccessKeySupported) { return; } element.SetLocalValue(ContentPresenterElement.RecognizesAccessKeyProperty, (object)true); }
protected void SetToResourceInternal(PropertyReference propertyReference, LocalResourceModel resourceModel) { using (SceneEditTransaction editTransaction = this.ViewModel.CreateEditTransaction(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.PropertySetUndo, new object[1] { (object)this.TargetProperty.Name }))) { IDocumentContext documentContext = this.ViewModel.Document.DocumentContext; DocumentNode keyNode = resourceModel.ResourceKey.Clone(documentContext); DocumentNode resourceExtensionNode = !(propertyReference[0] is DependencyPropertyReferenceStep) || !JoltHelper.TypeSupported((ITypeResolver)this.ViewModel.ProjectContext, PlatformTypes.DynamicResource) ? (DocumentNode)DocumentNodeUtilities.NewStaticResourceNode(documentContext, keyNode) : (DocumentNode)DocumentNodeUtilities.NewDynamicResourceNode(documentContext, keyNode); this.TargetElement.SetValue(propertyReference, (object)resourceExtensionNode); Microsoft.Expression.DesignSurface.Utility.ResourceHelper.EnsureReferencedResourcesAreReachable(resourceModel.ResourceNode, resourceExtensionNode); editTransaction.Commit(); } }
public List <ViewNode> Validate(IInstanceBuilderContext context, out List <ExpressionSite> sites) { ExpressionSite expressionSite; bool flag; DocumentNode item; DocumentNode documentNode; DocumentNode item1; List <DocumentNode> documentNodes = new List <DocumentNode>(); List <ViewNode> viewNodes = new List <ViewNode>(); List <ViewNode> viewNodes1 = new List <ViewNode>(); sites = new List <ExpressionSite>(); ExpressionEvaluator expressionEvaluator = new ExpressionEvaluator(context.DocumentRootResolver); foreach (KeyValuePair <DocumentNode, List <ViewNode> > keyValuePair in this) { DocumentNode key = keyValuePair.Key; viewNodes1.Clear(); foreach (ViewNode value in keyValuePair.Value) { ViewNode parent = value.Parent; if (parent != null) { DocumentNode documentNode1 = parent.DocumentNode; if (!value.IsProperty) { int num = value.Parent.Children.IndexOf(value); expressionSite = new ExpressionSite(num); } else { expressionSite = new ExpressionSite(value.SitePropertyKey); } bool flag1 = ExpressionCache.HasInvalidAncestor(context, parent, out flag); if (!flag) { continue; } if (!flag1) { DocumentNodePath correspondingNodePath = context.ViewNodeManager.GetCorrespondingNodePath(parent); DocumentCompositeNode node = (DocumentCompositeNode)correspondingNodePath.Node; if (expressionSite.IsProperty) { item = node.Properties[expressionSite.PropertyKey]; } else if (node.Children == null) { if (expressionSite.ChildIndex < node.ConstructorArguments.Count) { documentNode = node.ConstructorArguments[expressionSite.ChildIndex]; } else { documentNode = null; } item = documentNode; } else { if (expressionSite.ChildIndex < node.Children.Count) { item1 = node.Children[expressionSite.ChildIndex]; } else { item1 = null; } item = item1; } DocumentNode documentNode2 = value.DocumentNode; bool flag2 = true; if (item != null) { if (!DocumentNodeUtilities.IsBinding(value.DocumentNode)) { flag2 = false; documentNode2 = expressionEvaluator.EvaluateExpression(correspondingNodePath, item); } else { IPropertyId propertyId = value.DocumentNode.TypeResolver.ResolveProperty(Microsoft.Expression.DesignModel.Metadata.KnownProperties.BindingElementNameProperty); if (propertyId != null) { DocumentNode item2 = ((DocumentCompositeNode)value.DocumentNode).Properties[propertyId]; if (item2 != null) { DocumentPrimitiveNode documentPrimitiveNode = item2 as DocumentPrimitiveNode; if (documentPrimitiveNode != null) { DocumentNodeStringValue documentNodeStringValue = documentPrimitiveNode.Value as DocumentNodeStringValue; if (documentNodeStringValue != null) { string str = documentNodeStringValue.Value; object obj = context.NameScope.FindName(str); if (obj != null) { ViewNode viewNode = context.InstanceDictionary.GetViewNode(obj, false); InstanceState invalid = InstanceState.Invalid; if (viewNode != null && !ExpressionCache.HasInvalidAncestor(context, viewNode, out flag)) { invalid = viewNode.InstanceState; } if (invalid != InstanceState.Invalid && (invalid.InvalidProperties == null || !invalid.InvalidProperties.Contains(viewNode.DocumentNode.NameProperty))) { documentNode2 = viewNode.DocumentNode; flag2 = false; } else if (parent.Instance is VisualBrush && expressionSite.IsProperty && Microsoft.Expression.DesignModel.Metadata.KnownProperties.VisualBrushVisualProperty.Equals(expressionSite.PropertyKey)) { BindingOperations.ClearBinding((VisualBrush)parent.Instance, VisualBrush.VisualProperty); } } } } } } } } if (key != item == (documentNode2 != null) && (documentNode2 == null || documentNode2 == key) && !flag2) { continue; } viewNodes1.Add(value); viewNodes.Add(parent); sites.Add(expressionSite); } else { viewNodes1.Add(value); } } else { viewNodes1.Add(value); } } if (viewNodes1.Count != keyValuePair.Value.Count) { this.PurgePartialEntry(keyValuePair.Value, viewNodes1); } else { documentNodes.Add(keyValuePair.Key); } } foreach (DocumentNode documentNode3 in documentNodes) { base.Remove(documentNode3); } return(viewNodes); }