public static DocumentCompositeNode GetStyleSetter(DocumentCompositeNode styleNode, IPropertyId property)
{
DocumentCompositeNode documentCompositeNode;
if (styleNode != null && property != null)
{
IPlatformMetadata platformMetadata = styleNode.Context.TypeResolver.PlatformMetadata;
IProperty property1 = styleNode.Context.TypeResolver.ResolveProperty(property);
DocumentCompositeNode item = styleNode.Properties[platformMetadata.KnownProperties.StyleSetters] as DocumentCompositeNode;
if (item != null && item.SupportsChildren && property1 != null)
{
using (IEnumerator <DocumentNode> enumerator = item.Children.GetEnumerator())
{
while (enumerator.MoveNext())
{
DocumentCompositeNode current = enumerator.Current as DocumentCompositeNode;
if (current == null)
{
continue;
}
IMemberId valueAsMember = DocumentNodeHelper.GetValueAsMember(current, KnownProperties.SetterPropertyProperty);
if (valueAsMember == null || !property1.Equals(valueAsMember))
{
continue;
}
documentCompositeNode = current;
return(documentCompositeNode);
}
return(null);
}
return(documentCompositeNode);
}
}
return(null);
}
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);
}
private static Dictionary <IPropertyId, List <SceneNode> > StoreChildren(SceneElement sourceElement)
{
Dictionary <IPropertyId, List <SceneNode> > dictionary = new Dictionary <IPropertyId, List <SceneNode> >();
foreach (IPropertyId propertyId in sourceElement.ContentProperties)
{
ISceneNodeCollection <SceneNode> collectionForProperty = sourceElement.GetCollectionForProperty(propertyId);
if (collectionForProperty != null)
{
while (collectionForProperty.Count > 0)
{
SceneNode sceneNode = collectionForProperty[0];
if (sceneNode.DocumentNode != null)
{
DocumentNodeHelper.PreserveFormatting(sceneNode.DocumentNode);
}
sceneNode.Remove();
List <SceneNode> list = (List <SceneNode>)null;
if (!dictionary.TryGetValue(propertyId, out list))
{
list = new List <SceneNode>();
dictionary.Add(propertyId, list);
}
list.Add(sceneNode);
}
}
}
return(dictionary);
}
protected override bool DoesNodeReferenceUrl(DocumentNode node, string url)
{
DocumentCompositeNode documentCompositeNode = node as DocumentCompositeNode;
if (documentCompositeNode != null)
{
Uri uriValue = DocumentNodeHelper.GetUriValue(documentCompositeNode.Properties[ImageElement.SourceProperty]);
string uriString = uriValue != (Uri)null ? uriValue.OriginalString : (string)null;
if (!string.IsNullOrEmpty(uriString))
{
Uri uri = node.Context.MakeDesignTimeUri(new Uri(uriString, UriKind.RelativeOrAbsolute));
if (!uri.IsAbsoluteUri)
{
return(false);
}
string localPath = uri.LocalPath;
if (StringComparer.OrdinalIgnoreCase.Compare(localPath, url) == 0)
{
return(true);
}
return(StringComparer.OrdinalIgnoreCase.Compare(localPath.Replace("file:///", "").Replace("/", "\\"), url) == 0);
}
}
return(false);
}
public static Dictionary <IPropertyId, SceneNode> StoreProperties(SceneNode sourceNode, IEnumerable <IPropertyId> propertyFilter, bool detachProperties)
{
Dictionary <IPropertyId, SceneNode> dictionary = new Dictionary <IPropertyId, SceneNode>();
List <IPropertyId> list = new List <IPropertyId>();
ReadOnlyCollection <IPropertyId> contentProperties = sourceNode.ContentProperties;
DocumentCompositeNode documentCompositeNode = sourceNode.DocumentNode as DocumentCompositeNode;
if (documentCompositeNode != null)
{
if (propertyFilter == null)
{
foreach (IPropertyId propertyId in (IEnumerable <IProperty>)documentCompositeNode.Properties.Keys)
{
list.Add(propertyId);
}
}
else
{
foreach (IPropertyId propertyId in propertyFilter)
{
IProperty property = sourceNode.ProjectContext.ResolveProperty(propertyId);
if (property != null && documentCompositeNode.Properties.Keys.Contains(property))
{
list.Add((IPropertyId)property);
}
}
}
}
foreach (IPropertyId propertyId in list)
{
if (!contentProperties.Contains(propertyId))
{
DocumentNode node;
using (sourceNode.ViewModel.ForceBaseValue())
node = sourceNode.GetLocalValueAsDocumentNode(propertyId).Node;
if (node != null)
{
if (detachProperties)
{
DocumentNodeHelper.PreserveFormatting(node);
sourceNode.ClearLocalValue(propertyId);
}
else
{
node = node.Clone(sourceNode.DocumentContext);
}
dictionary.Add(propertyId, sourceNode.ViewModel.GetSceneNode(node));
}
}
}
return(dictionary);
}
private static SceneNode GetHighestDataContextHost(SceneNode sceneNode)
{
SceneNode sceneNode1 = (SceneNode)null;
for (SceneNode sceneNode2 = sceneNode; sceneNode2 != null && (!DocumentNodeHelper.IsStyleOrTemplate(sceneNode2.Type) && !PlatformTypes.DictionaryEntry.IsAssignableFrom((ITypeId)sceneNode2.Type)); sceneNode2 = sceneNode2.Parent)
{
if (DataContextHelper.HasDataContextProperty(sceneNode2.Type) && (sceneNode1 == null || sceneNode2.Parent != null))
{
sceneNode1 = sceneNode2;
}
}
return(sceneNode1);
}
protected override object GetComputedValueInternal(PropertyReference propertyReference)
{
if (propertyReference.Count != 1 || !ImageElement.SourceProperty.Equals((object)propertyReference.FirstStep))
{
return(base.GetComputedValueInternal(propertyReference));
}
SceneNode valueAsSceneNode = this.GetLocalValueAsSceneNode(propertyReference);
if (valueAsSceneNode != null && valueAsSceneNode.TargetType == typeof(BitmapImage))
{
return((object)DocumentNodeHelper.GetUriValue(valueAsSceneNode.DocumentNode));
}
return(this.GetLocalOrDefaultValue(propertyReference));
}
protected override ModelItem CreateStaticMemberItem(Type type, string memberName)
{
IType type1 = this.viewModel.ProjectContext.GetType(type);
if (type1 != null)
{
MemberAccessTypes allowableMemberAccess = TypeHelper.GetAllowableMemberAccess((ITypeResolver)this.viewModel.ProjectContext, type1);
IMember memberId = type1.GetMember(MemberType.LocalProperty | MemberType.Field, memberName, allowableMemberAccess) as IMember;
if (memberId != null)
{
return((ModelItem)this.viewModel.GetSceneNode((DocumentNode)DocumentNodeHelper.NewStaticNode(this.viewModel.Document.DocumentContext, memberId)).ModelItem);
}
}
return((ModelItem)null);
}
public static bool UseDesignTimeSize(object target, IInstanceBuilderContext context)
{
bool documentNode = false;
if (context != null && context.ContainerRoot != null && context.ContainerRoot.DocumentNode != null && context.ContainerRoot.DocumentNode.DocumentRoot != null && context.ViewNodeManager != null && context.ViewNodeManager.Root != null)
{
ViewNode viewNode = context.InstanceDictionary.GetViewNode(target, true);
if ((viewNode == null ? true : viewNode.Parent != null))
{
documentNode = context.ViewNodeManager.Root.DocumentNode != context.ContainerRoot.DocumentNode.DocumentRoot.RootNode;
IInstantiatedElementViewNode root = context.ViewNodeManager.Root as IInstantiatedElementViewNode;
if (documentNode && root != null)
{
object first = root.InstantiatedElements.First;
if (first != null && (bool)(context.DocumentContext.TypeResolver.ResolveProperty(DesignTimeProperties.IsEnhancedOutOfPlaceRootProperty) as DependencyPropertyReferenceStep).GetValue(first))
{
documentNode = false;
}
}
if (documentNode && viewNode != null)
{
DocumentNodePath containerNodePath = context.ViewNodeManager.GetCorrespondingNodePath(viewNode).GetContainerNodePath();
if (PlatformTypes.ControlTemplate.Equals(containerNodePath.Node.Type) && containerNodePath.Node != context.ViewNodeManager.Root.DocumentNode)
{
DocumentNodePath parent = containerNodePath.GetParent();
if (parent.Node.Type.Equals(PlatformTypes.Setter) && parent.Node is DocumentCompositeNode)
{
IMemberId valueAsMember = DocumentNodeHelper.GetValueAsMember((DocumentCompositeNode)parent.Node, Microsoft.Expression.DesignModel.Metadata.KnownProperties.SetterPropertyProperty);
if (valueAsMember.Equals(Microsoft.Expression.DesignModel.Metadata.KnownProperties.ControlTemplateProperty) || valueAsMember.Equals(Microsoft.Expression.DesignModel.Metadata.KnownProperties.PageTemplateProperty))
{
containerNodePath = parent.GetContainerNodePath();
}
}
}
if (containerNodePath.Node != context.ViewNodeManager.Root.DocumentNode)
{
documentNode = false;
}
}
}
else
{
documentNode = true;
}
}
return(documentNode);
}
public InvalidReferenceModel(DocumentCompositeNode invalidObjectNode, IPropertyId invalidProperty, string invalidPropertyValue)
{
DocumentNode node = invalidObjectNode.Properties[invalidProperty];
if (node != null)
{
DocumentNodeHelper.GetNodeSpan(node);
}
else
{
DocumentNodeHelper.GetNodeSpan((DocumentNode)invalidObjectNode);
}
this.InvalidValueNode = node ?? (DocumentNode)invalidObjectNode;
this.InvalidNodeName = invalidObjectNode.Name;
this.InvalidNodeType = (ITypeId)invalidObjectNode.Type;
this.InvalidProperty = invalidProperty;
this.InvalidPropertyValue = invalidPropertyValue;
}
internal static void ReparentAction(ISceneNodeCollection <SceneNode> triggersCollection, BehaviorTriggerBaseNode oldTrigger, BehaviorTriggerBaseNode newTrigger, BehaviorTriggerActionNode action)
{
SceneViewModel viewModel = oldTrigger.ViewModel;
viewModel.BehaviorSelectionSet.Clear();
int num = triggersCollection.IndexOf((SceneNode)oldTrigger);
DocumentNodeHelper.PreserveFormatting(action.DocumentNode);
oldTrigger.Actions.Remove((SceneNode)action);
viewModel.Document.OnUpdatedEditTransaction();
if (oldTrigger.Actions.Count == 0)
{
triggersCollection.RemoveAt(num--);
}
if (!triggersCollection.Contains((SceneNode)newTrigger))
{
triggersCollection.Insert(num + 1, (SceneNode)newTrigger);
}
newTrigger.Actions.Add((SceneNode)action);
viewModel.BehaviorSelectionSet.SetSelection((BehaviorBaseNode)action);
}
public static string GetDataSourceName(DocumentNode dataSourceNode)
{
string str = (string)null;
if (dataSourceNode != null)
{
DocumentCompositeNode parent = dataSourceNode.Parent;
if (parent != null && PlatformTypes.DictionaryEntry.IsAssignableFrom((ITypeId)parent.Type))
{
DocumentNode resourceEntryKey = DocumentNodeHelper.GetResourceEntryKey(parent);
if (resourceEntryKey != null)
{
str = DocumentPrimitiveNode.GetValueAsString(resourceEntryKey);
}
}
if (string.IsNullOrEmpty(str))
{
str = dataSourceNode.Type.Name + (object)" " + (string)(object)dataSourceNode.GetHashCode();
}
}
return(str ?? string.Empty);
}
private static DocumentNodePath FindTemplateWithinStyle(DocumentNodePath styleNodePath, SceneElement targetElement, IPropertyId targetSetterProperty, IPropertyId targetProperty)
{
DocumentCompositeNode documentCompositeNode1 = styleNodePath.Node as DocumentCompositeNode;
if (documentCompositeNode1 != null && PlatformTypes.Style.IsAssignableFrom((ITypeId)documentCompositeNode1.Type))
{
DocumentCompositeNode documentCompositeNode2 = documentCompositeNode1.Properties[StyleNode.SettersProperty] as DocumentCompositeNode;
if (documentCompositeNode2 != null && PlatformTypes.SetterBaseCollection.IsAssignableFrom((ITypeId)documentCompositeNode2.Type) && documentCompositeNode2.SupportsChildren)
{
foreach (DocumentNode documentNode in (IEnumerable <DocumentNode>)documentCompositeNode2.Children)
{
DocumentCompositeNode valueNode = documentNode as DocumentCompositeNode;
if (valueNode != null && PlatformTypes.Setter.IsAssignableFrom((ITypeId)valueNode.Type))
{
IProperty property = DocumentNodeHelper.GetValueAsMember(valueNode, SetterSceneNode.PropertyProperty) as IProperty;
if (targetSetterProperty.Equals((object)property))
{
DocumentNode expression = valueNode.Properties[SetterSceneNode.ValueProperty];
if (expression != null)
{
DocumentNodePath pathInContainer = styleNodePath.GetPathInContainer((DocumentNode)valueNode);
DocumentNode newContainer = new ExpressionEvaluator(targetElement.ViewModel.DocumentRootResolver).EvaluateExpression(pathInContainer, expression);
if (newContainer != null && newContainer.Parent != null)
{
DocumentNodePath pathInSubContainer = pathInContainer.GetPathInSubContainer(newContainer.SitePropertyKey, newContainer);
if (ControlStylingOperations.ShouldSetEditingContextToNodePath(pathInSubContainer, targetElement, (ReferenceStep)documentCompositeNode1.TypeResolver.ResolveProperty(targetProperty)))
{
return(pathInSubContainer);
}
}
}
}
}
}
}
}
return((DocumentNodePath)null);
}
public DocumentNode EvaluateResourceAndCollectionPath(DocumentNodePath nodePath, ResourceReferenceType referenceType, DocumentNode keyNode, ICollection <DocumentCompositeNode> resourcesHostNodePath, ICollection <IDocumentRoot> relatedRoots, ICollection <string> warnings, out bool invalidForwardReference)
{
Uri uri;
DocumentNode documentNode;
IDocumentRoot applicationRoot;
IDocumentRoot documentRoot = nodePath.RootNode.DocumentRoot;
if (this.documentRootResolver != null)
{
applicationRoot = this.documentRootResolver.ApplicationRoot;
}
else
{
applicationRoot = null;
}
IDocumentRoot documentRoot1 = applicationRoot;
bool flag = (documentRoot1 == null ? false : documentRoot1.RootNode != null);
IDocumentRoot documentRoot2 = null;
invalidForwardReference = false;
if (referenceType != ResourceReferenceType.Static)
{
DocumentNode node = nodePath.Node;
while (node != null)
{
if (flag && node.DocumentRoot != null && node == node.DocumentRoot.RootNode && PlatformTypes.ResourceDictionary.IsAssignableFrom(node.Type))
{
string documentUrl = node.Context.DocumentUrl;
DocumentCompositeNode rootNode = documentRoot1.RootNode as DocumentCompositeNode;
if (rootNode != null && Uri.TryCreate(documentUrl, UriKind.Absolute, out uri) && ResourceNodeHelper.FindReferencedDictionaries(rootNode).Contains <Uri>(uri))
{
documentRoot2 = node.DocumentRoot;
break;
}
}
DocumentNode documentNode1 = this.EvaluateResourceAtSpecificNode(node, keyNode, resourcesHostNodePath, relatedRoots, warnings);
if (documentNode1 != null)
{
return(documentNode1);
}
node = node.Parent;
if (node == null || nodePath == null)
{
continue;
}
DocumentNode containerNode = nodePath.ContainerNode;
DocumentNode styleForSetter = ExpressionEvaluator.GetStyleForSetter(node);
if (styleForSetter == null || styleForSetter != containerNode)
{
styleForSetter = ExpressionEvaluator.GetStyleForResourceEntry(node);
if (styleForSetter == null)
{
if (node != containerNode)
{
continue;
}
nodePath = null;
}
else
{
if (styleForSetter == containerNode)
{
nodePath = null;
}
node = styleForSetter.Parent;
}
}
else
{
nodePath = nodePath.GetContainerOwnerPath();
if (nodePath == null)
{
continue;
}
node = nodePath.Node;
}
}
}
else
{
DocumentNode documentNode2 = null;
for (DocumentNode i = nodePath.Node; i != null; i = i.Parent)
{
ISupportsResources resourcesCollection = ResourceNodeHelper.GetResourcesCollection(i);
if (resourcesCollection != null)
{
ResourceSite resourceSite = new ResourceSite(i.Context, resourcesCollection);
DocumentNode documentNode3 = null;
if (ResourceNodeHelper.IsResourceDictionary(resourcesCollection))
{
int siteChildIndex = -1;
if (documentNode2 != null)
{
siteChildIndex = documentNode2.SiteChildIndex;
}
documentNode3 = this.EvaluateResourceAtSpecificSite(resourceSite, keyNode, resourcesHostNodePath, relatedRoots, siteChildIndex, warnings);
}
else if (ResourceNodeHelper.IsResourceContainer(resourcesCollection, documentNode2))
{
documentNode3 = this.EvaluateResourceAtSpecificSite(resourceSite, keyNode, resourcesHostNodePath, relatedRoots, -1, warnings);
}
if (documentNode3 != null)
{
if (keyNode != null && keyNode.Parent != null && keyNode.Parent.Parent == i)
{
ITextRange nodeSpan = DocumentNodeHelper.GetNodeSpan(keyNode.Parent);
ITextRange textRange = DocumentNodeHelper.GetNodeSpan(documentNode3);
if (!TextRange.IsNull(textRange) && !TextRange.IsNull(nodeSpan) && nodeSpan.Offset < textRange.Offset)
{
documentNode3 = null;
invalidForwardReference = true;
}
}
if (documentNode3 != null)
{
return(documentNode3);
}
}
}
documentNode2 = i;
}
}
if (flag)
{
DocumentNode documentNode4 = this.EvaluateResourceAtSpecificNode(documentRoot1.RootNode, keyNode, resourcesHostNodePath, relatedRoots, warnings);
if (documentNode4 != null)
{
if (relatedRoots != null && documentNode4.DocumentRoot != documentRoot2)
{
relatedRoots.Add(documentRoot1);
}
return(documentNode4);
}
}
if (documentRoot != null)
{
using (IEnumerator <IDocumentRoot> enumerator = documentRoot.DesignTimeResources.GetEnumerator())
{
while (enumerator.MoveNext())
{
IDocumentRoot current = enumerator.Current;
DocumentNode documentNode5 = this.EvaluateResourceAtSpecificNode(current.RootNode, keyNode, resourcesHostNodePath, relatedRoots, warnings);
if (documentNode5 == null)
{
continue;
}
if (relatedRoots != null && documentNode5.DocumentRoot != documentRoot2)
{
relatedRoots.Add(current);
}
documentNode = documentNode5;
return(documentNode);
}
return(null);
}
return(documentNode);
}
return(null);
}
public static bool IsStyleOrTemplate(IType type)
{
return(DocumentNodeHelper.IsStyleOrTemplate(type));
}
public static void PrepareNodeForTextDeletion(IDocumentRoot documentRoot, DocumentNode node)
{
node.ClearOldSourceContainerContext();
DocumentNodeHelper.PreserveFormatting(documentRoot, node);
}
public static void GoToXaml(SceneView sceneView, SceneXamlDocument document, List <DocumentNode> targetNodes, bool selectElementNameOnly, bool setFocusToXamlEditor)
{
ITextRange selectionSpan = TextRange.Null;
bool flag = false;
ProjectXamlContext projectXamlContext = ProjectXamlContext.FromProjectContext(document.ProjectContext);
if (projectXamlContext == null)
{
return;
}
DocumentNode rootNode = document.RootNode;
if (rootNode != null && targetNodes != null)
{
foreach (DocumentNode documentNode in targetNodes)
{
DocumentNode node = GoToXamlCommand.GetCorrespondingDocumentNode(documentNode, rootNode);
if (node != null)
{
ITextRange nodeSpan;
for (nodeSpan = DocumentNodeHelper.GetNodeSpan(node); TextRange.IsNull(nodeSpan) && node != null && node != rootNode; nodeSpan = DocumentNodeHelper.GetNodeSpan(node))
{
node = (DocumentNode)node.Parent;
}
if (!TextRange.IsNull(nodeSpan))
{
if (!flag)
{
flag = true;
selectionSpan = nodeSpan;
}
else
{
selectionSpan = TextRange.Union(selectionSpan, nodeSpan);
}
}
}
}
}
if (sceneView == null)
{
sceneView = projectXamlContext.OpenView((IDocumentRoot)document, true);
}
using (sceneView.DisableSelectionSynchronization())
{
sceneView.EnsureXamlEditorVisible();
if (!flag || sceneView.CodeEditor == null)
{
return;
}
ITextEditor textEditor = sceneView.CodeEditor;
textEditor.ClearSelection();
if (selectElementNameOnly)
{
selectionSpan = GoToXamlCommand.GetElementNameSelectionSpan((IReadableSelectableTextBuffer)document.TextBuffer, selectionSpan);
}
textEditor.Select(selectionSpan.Offset, selectionSpan.Length);
textEditor.CaretPosition = selectionSpan.Offset + selectionSpan.Length;
Action action = (Action)(() =>
{
textEditor.EnsureSpanVisible(selectionSpan.Offset, selectionSpan.Length);
textEditor.EnsureCaretVisible();
textEditor.MoveLineToCenterOfView(textEditor.GetLineNumberFromPosition(selectionSpan.Offset));
if (!setFocusToXamlEditor)
{
return;
}
textEditor.Focus();
});
if (SceneViewUpdateScheduleTask.Synchronous)
{
action();
}
else
{
UIThreadDispatcher.Instance.BeginInvoke(DispatcherPriority.Render, action);
}
}
}
private static void PasteChildProperty(SceneViewModel viewModel, SceneNode childProperty, IList <SceneNode> pastedNodes)
{
IList <SceneElement> list = (IList <SceneElement>)null;
DocumentNodeHelper.StripExtraNamespaces(childProperty.DocumentNode);
if (viewModel.ElementSelectionSet.Selection.Count != 0)
{
list = (IList <SceneElement>)viewModel.ElementSelectionSet.Selection;
}
else if (viewModel.ChildPropertySelectionSet.Selection.Count != 0 && !(childProperty is BehaviorBaseNode) && !(childProperty is BehaviorTriggerBaseNode))
{
list = (IList <SceneElement>) new List <SceneElement>();
foreach (SceneNode sceneNode in viewModel.ChildPropertySelectionSet.Selection)
{
SceneElement sceneElement = sceneNode.Parent as SceneElement;
list.Add(sceneElement);
}
}
if (list == null)
{
return;
}
IProperty targetProperty = viewModel.ProjectContext.ResolveProperty(PasteCommand.ChildSceneNodeToPropertyId(childProperty));
foreach (SceneElement sceneElement in (IEnumerable <SceneElement>)list)
{
PropertySceneInsertionPoint sceneInsertionPoint = new PropertySceneInsertionPoint(sceneElement, targetProperty);
if (sceneInsertionPoint.CanInsert((ITypeId)childProperty.Type))
{
if (ProjectNeutralTypes.BehaviorTriggerBase.IsAssignableFrom((ITypeId)childProperty.Type))
{
BehaviorTriggerBaseNode behaviorTriggerBaseNode1 = (BehaviorTriggerBaseNode)childProperty;
bool flag = true;
foreach (SceneNode sceneNode in (IEnumerable <SceneNode>)behaviorTriggerBaseNode1.Actions)
{
if (!sceneInsertionPoint.CanInsert((ITypeId)sceneNode.Type))
{
flag = false;
break;
}
}
if (flag)
{
ISceneNodeCollection <SceneNode> collectionForProperty = sceneElement.GetCollectionForProperty((IPropertyId)targetProperty);
BehaviorTriggerBaseNode behaviorTriggerBaseNode2 = BehaviorHelper.FindMatchingTriggerNode(behaviorTriggerBaseNode1.DocumentNode, collectionForProperty);
if (behaviorTriggerBaseNode2 == null)
{
DocumentNode node = behaviorTriggerBaseNode1.DocumentNode.Clone(behaviorTriggerBaseNode1.DocumentContext);
behaviorTriggerBaseNode2 = (BehaviorTriggerBaseNode)viewModel.GetSceneNode(node);
collectionForProperty.Add((SceneNode)behaviorTriggerBaseNode2);
}
else
{
DocumentNode node = behaviorTriggerBaseNode1.Actions[0].DocumentNode.Clone(behaviorTriggerBaseNode1.Actions[0].DocumentNode.Context);
BehaviorTriggerActionNode triggerActionNode = (BehaviorTriggerActionNode)viewModel.GetSceneNode(node);
behaviorTriggerBaseNode2.Actions.Add((SceneNode)triggerActionNode);
}
BehaviorEventTriggerNode eventTriggerNode = behaviorTriggerBaseNode2 as BehaviorEventTriggerNode;
if (eventTriggerNode != null)
{
BehaviorEventTriggerNode.FixUpEventName(eventTriggerNode);
}
}
else
{
continue;
}
}
else
{
DocumentNode node = childProperty.DocumentNode.Clone(childProperty.DocumentNode.Context);
SceneNode sceneNode = viewModel.GetSceneNode(node);
sceneInsertionPoint.Insert(sceneNode);
if (sceneNode is EffectNode)
{
pastedNodes.Add(sceneNode);
}
}
TimelineItem timelineItem = viewModel.TimelineItemManager.FindTimelineItem((SceneNode)sceneElement);
if (timelineItem != null)
{
timelineItem.IsExpanded = true;
}
}
}
}
public static DocumentNode GetResourceEntryKey(DocumentCompositeNode entryNode)
{
return(DocumentNodeHelper.GetResourceEntryKey(entryNode));
}
public static bool IsMarkupExtension(DocumentNode node)
{
return(DocumentNodeHelper.IsMarkupExtension(node));
}
public static void StripExtraNamespaces(SceneElement element)
{
DocumentNodeHelper.StripExtraNamespaces(element.DocumentNode);
}
public static void DeleteBehavior(BehaviorBaseNode node)
{
Stack <ReferenceStep> input = new Stack <ReferenceStep>();
SceneNode parent1 = node.Parent;
SceneNode child1 = (SceneNode)node;
while (true)
{
ReferenceStep referenceStep = (ReferenceStep)parent1.GetPropertyForChild(child1);
if (parent1.IsCollectionProperty((IPropertyId)referenceStep))
{
int index = parent1.GetCollectionForProperty((IPropertyId)referenceStep).IndexOf(child1);
input.Push((ReferenceStep)IndexedClrPropertyReferenceStep.GetReferenceStep((ITypeResolver)node.ProjectContext, (ITypeId)referenceStep.PropertyType, index));
}
input.Push(referenceStep);
if (!(parent1 is SceneElement))
{
child1 = parent1;
parent1 = parent1.Parent;
}
else
{
break;
}
}
SceneElement sceneElement = (SceneElement)parent1;
SceneNode parent2 = node.Parent;
PropertyReference propertyReference = new PropertyReference(input);
node.ViewModel.AnimationEditor.DeleteAllAnimations((SceneNode)sceneElement, propertyReference.ToString());
SceneNode child2 = (SceneNode)node;
int num = propertyReference.Count - 1;
ISceneNodeCollection <SceneNode> collectionForChild;
int endIndex;
while (true)
{
SceneNode parent3 = child2.Parent;
if (sceneElement != child2 && parent3 != null)
{
ReferenceStep referenceStep = (ReferenceStep)parent3.GetPropertyForChild(child2);
collectionForChild = parent3.GetCollectionForChild(child2);
DocumentNodeHelper.PreserveFormatting(child2.DocumentNode);
endIndex = propertyReference.ReferenceSteps.IndexOf(referenceStep);
if (collectionForChild.Count == 1)
{
child2.Remove();
child2 = parent3;
}
else
{
goto label_10;
}
}
else
{
break;
}
}
sceneElement.ClearValue((IPropertyId)propertyReference.FirstStep);
goto label_11;
label_10:
int index1 = collectionForChild.IndexOf(child2);
child2.ViewModel.AnimationEditor.ValidateAnimations((SceneNode)sceneElement, propertyReference.Subreference(0, endIndex), index1, false);
child2.Remove();
label_11:
node.ViewModel.Document.OnUpdatedEditTransaction();
}
public static ITypeId GetStyleOrTemplateTypeAndTargetType(DocumentNode node, out IType styleOrTemplateType)
{
return(DocumentNodeHelper.GetStyleOrTemplateTypeAndTargetType(node, out styleOrTemplateType));
}
public static DocumentCompositeNode NewStaticNode(IDocumentContext documentContext, IMember memberId)
{
return(DocumentNodeHelper.NewStaticNode(documentContext, memberId));
}
private SceneNode[] Ungroup(SceneEditTransaction transaction, BaseFrameworkElement group)
{
SceneElement parentElement = group.ParentElement;
if (parentElement == null)
{
return(new SceneNode[0]);
}
transaction.Update();
ILayoutDesigner designerForParent1 = this.SceneViewModel.GetLayoutDesignerForParent(parentElement, true);
Rect childRect = designerForParent1.GetChildRect(group);
Matrix effectiveRenderTransform = group.GetEffectiveRenderTransform(false);
SceneNode[] array = new SceneNode[group.DefaultContent.Count];
group.DefaultContent.CopyTo(array, 0);
using (this.SceneViewModel.DisableUpdateChildrenOnAddAndRemove())
{
Transform[] transformArray = new Transform[array.Length];
Point[] pointArray = new Point[array.Length];
LayoutCacheRecord[] layoutCacheRecordArray = new LayoutCacheRecord[array.Length];
ILayoutDesigner designerForParent2 = group.ViewModel.GetLayoutDesignerForParent((SceneElement)group, true);
for (int index = 0; index < array.Length; ++index)
{
BaseFrameworkElement frameworkElement = array[index] as BaseFrameworkElement;
if (frameworkElement != null)
{
transformArray[index] = (Transform)frameworkElement.GetComputedValueAsWpf(Base2DElement.RenderTransformProperty);
pointArray[index] = frameworkElement.RenderTransformOrigin;
designerForParent2.GetChildRect(frameworkElement);
LayoutCacheRecord layoutCacheRecord = designerForParent2.CacheLayout(frameworkElement);
layoutCacheRecordArray[index] = layoutCacheRecord;
}
}
int num1;
if (array.Length == 1 && array[0] is BaseFrameworkElement)
{
int?fixedCapacity = group.DefaultContent.FixedCapacity;
num1 = fixedCapacity.GetValueOrDefault() != 1 ? 0 : (fixedCapacity.HasValue ? true : false);
}
else
{
num1 = 0;
}
bool flag = num1 != 0;
if (flag)
{
Dictionary <IPropertyId, SceneNode> properties = SceneElementHelper.StoreProperties((SceneNode)group, designerForParent1.GetLayoutProperties(), true);
SceneElementHelper.FixElementNameBindingsInStoredProperties((SceneNode)group, array[0], properties);
if (!SceneElementHelper.ApplyProperties(array[0], properties))
{
flag = false;
}
}
if (array.Length == 1 && array[0] is SceneElement)
{
VisualStateManagerSceneNode.MoveStates((SceneElement)group, (SceneElement)array[0]);
}
using (this.SceneViewModel.ForceBaseValue())
{
SceneElement sceneElement = (SceneElement)null;
for (int index = 0; index < array.Length; ++index)
{
BaseFrameworkElement frameworkElement = array[index] as BaseFrameworkElement;
if (frameworkElement != null)
{
if (this.SceneViewModel.LockedInsertionPoint != null && this.SceneViewModel.LockedInsertionPoint.SceneElement == frameworkElement)
{
sceneElement = (SceneElement)frameworkElement;
}
DocumentNodeHelper.PreserveFormatting(frameworkElement.DocumentNode);
frameworkElement.Remove();
}
}
ISceneNodeCollection <SceneNode> collectionContainer = group.GetCollectionContainer();
int index1 = collectionContainer.IndexOf((SceneNode)group);
this.SceneViewModel.AnimationEditor.DeleteAllAnimationsInSubtree((SceneElement)group);
this.SceneViewModel.RemoveElement((SceneNode)group);
Matrix matrix1 = effectiveRenderTransform;
matrix1.OffsetX = 0.0;
matrix1.OffsetY = 0.0;
for (int index2 = array.Length - 1; index2 >= 0; --index2)
{
BaseFrameworkElement frameworkElement = array[index2] as BaseFrameworkElement;
if (frameworkElement != null)
{
Matrix matrix2 = (transformArray[index2] ?? Transform.Identity).Value;
collectionContainer.Insert(index1, (SceneNode)frameworkElement);
CanonicalTransform canonicalTransform = new CanonicalTransform((Transform) new MatrixTransform(matrix2 * matrix1));
if (frameworkElement.GetLocalValue(Base2DElement.RenderTransformProperty) != null || !canonicalTransform.TransformGroup.Value.IsIdentity)
{
frameworkElement.SetValue(Base2DElement.RenderTransformProperty, canonicalTransform.GetPlatformTransform(frameworkElement.Platform.GeometryHelper));
if (frameworkElement.IsSet(Base2DElement.RenderTransformOriginProperty) == PropertyState.Unset)
{
frameworkElement.SetValueAsWpf(Base2DElement.RenderTransformOriginProperty, (object)new Point(0.5, 0.5));
}
}
}
}
transaction.Update();
if (sceneElement != null)
{
this.SceneViewModel.SetLockedInsertionPoint(sceneElement);
}
bool[] flagArray = new bool[array.Length];
int length = 0;
for (int index2 = 0; index2 < array.Length; ++index2)
{
BaseFrameworkElement frameworkElement = array[index2] as BaseFrameworkElement;
if (frameworkElement != null && array[index2].Parent != null)
{
if (!flag)
{
LayoutCacheRecord layoutCacheRecord = layoutCacheRecordArray[index2];
Rect rect1 = layoutCacheRecord.Rect;
Point point1 = new Point(rect1.X + rect1.Width * pointArray[index2].X, rect1.Y + rect1.Height * pointArray[index2].Y);
Point point2 = effectiveRenderTransform.Transform(point1);
Rect rect2 = new Rect(rect1.TopLeft + point2 - point1 + (Vector)childRect.TopLeft, rect1.Size);
designerForParent1.ClearUnusedLayoutProperties(frameworkElement);
designerForParent1.SetChildRect(frameworkElement, rect2, layoutCacheRecord.Overrides, LayoutOverrides.Margin | LayoutOverrides.GridBox, LayoutOverrides.None);
}
flagArray[index2] = true;
++length;
}
}
SceneNode[] sceneNodeArray = new SceneNode[length];
int num2 = 0;
for (int index2 = 0; index2 < array.Length; ++index2)
{
if (flagArray[index2])
{
sceneNodeArray[num2++] = array[index2];
}
}
return(sceneNodeArray);
}
}
}
private static bool ShouldNavigateToIntermediateStyle(ControlStylingOperations.EditScope scope, out ControlStylingOperations.EditScope templateScope, out ControlStylingOperations.EditScope styleScope)
{
styleScope = (ControlStylingOperations.EditScope)null;
templateScope = (ControlStylingOperations.EditScope)null;
if (scope.EditInPlace || scope.Node == null || (scope.NodePath == null || PlatformTypes.Style.IsAssignableFrom((ITypeId)scope.TargetElement.Type)) || !PlatformTypes.FrameworkTemplate.IsAssignableFrom((ITypeId)scope.Node.Type))
{
return(false);
}
DocumentCompositeNode valueNode = scope.NodePath.ContainerOwner as DocumentCompositeNode;
if (valueNode == null || !PlatformTypes.Setter.IsAssignableFrom((ITypeId)valueNode.Type) || (valueNode.SitePropertyKey != null || valueNode.SiteChildIndex < 0))
{
return(false);
}
DocumentCompositeNode parent1 = valueNode.Parent;
if (parent1 == null || !PlatformTypes.SetterBaseCollection.IsAssignableFrom((ITypeId)parent1.Type) || (parent1.SitePropertyKey == null || !StyleNode.SettersProperty.Equals((object)parent1.SitePropertyKey)))
{
return(false);
}
DocumentCompositeNode parent2 = parent1.Parent;
if (parent2 == null || !PlatformTypes.Style.IsAssignableFrom((ITypeId)parent2.Type))
{
return(false);
}
ReferenceStep referenceStep1 = DocumentNodeHelper.GetValueAsMember(valueNode, SetterSceneNode.PropertyProperty) as ReferenceStep;
if (referenceStep1 == null || !PlatformTypes.FrameworkTemplate.IsAssignableFrom((ITypeId)referenceStep1.PropertyType))
{
return(false);
}
DocumentNodePath containerOwnerPath = scope.NodePath.GetContainerOwnerPath();
if (containerOwnerPath == null || containerOwnerPath.ContainerOwner == null)
{
return(false);
}
ReferenceStep referenceStep2 = (ReferenceStep)null;
for (; containerOwnerPath != null; containerOwnerPath = containerOwnerPath.GetContainerOwnerPath())
{
if (PlatformTypes.DictionaryEntry.IsAssignableFrom((ITypeId)containerOwnerPath.ContainerOwner.Type))
{
referenceStep2 = containerOwnerPath.Node.TypeResolver.ResolveProperty(BaseFrameworkElement.StyleProperty) as ReferenceStep;
break;
}
referenceStep2 = !PlatformTypes.Setter.IsAssignableFrom((ITypeId)containerOwnerPath.ContainerOwner.Type) ? containerOwnerPath.ContainerOwnerProperty as ReferenceStep : DocumentNodeHelper.GetValueAsMember((DocumentCompositeNode)containerOwnerPath.ContainerOwner, SetterSceneNode.PropertyProperty) as ReferenceStep;
if (StyleNode.BasedOnProperty.Equals((object)referenceStep2))
{
referenceStep2 = (ReferenceStep)null;
}
else
{
break;
}
}
if (referenceStep2 == null || !PlatformTypes.Style.IsAssignableFrom((ITypeId)referenceStep2.PropertyType))
{
return(false);
}
styleScope = new ControlStylingOperations.EditScope()
{
TargetElement = scope.TargetElement,
TargetProperty = referenceStep2
};
if (!ControlStylingOperations.UpdateNavigationInfo(styleScope))
{
return(false);
}
templateScope = new ControlStylingOperations.EditScope()
{
TargetProperty = referenceStep1
};
return(true);
}
public static IType GetStyleOrTemplateTargetType(DocumentNode node)
{
return(DocumentNodeHelper.GetStyleOrTemplateTargetType(node));
}
public static DocumentNode ParseMarkupExtension(XamlParserContext parserContext, ITextLocation lineInformation, IDocumentNodeReference nodeReference, IXmlNamespaceResolver xmlNamespaceResolver, IType valueType, string text)
{
MarkupExtensionDescription description = MarkupExtensionParser.Tokenize(parserContext, lineInformation, text);
if (description != null)
{
IType typeId1 = XamlTypeHelper.GetTypeId(parserContext, lineInformation, xmlNamespaceResolver, description.Name, true);
if (typeId1 != null)
{
if (parserContext.PlatformMetadata.KnownTypes.NullExtension.Equals((object)typeId1))
{
if (description.PositionalArguments.Count > 0 || description.NamedArguments.Count > 0)
{
parserContext.ReportError(XamlParseErrors.InvalidMarkupExtensionArguments(lineInformation, description.Name));
}
if (valueType.SupportsNullValues)
{
return((DocumentNode)parserContext.DocumentContext.CreateNode((ITypeId)valueType, (IDocumentNodeValue)null));
}
parserContext.ReportError(XamlParseErrors.TypeIsNotNullable(lineInformation, (ITypeId)valueType));
return((DocumentNode)null);
}
if (parserContext.PlatformMetadata.KnownTypes.TypeExtension.IsAssignableFrom((ITypeId)typeId1))
{
string extensionArgument = MarkupExtensionParser.GetRequiredMarkupExtensionArgument(parserContext, lineInformation, description, parserContext.PlatformMetadata.KnownProperties.TypeExtensionTypeName.Name);
if (extensionArgument != null)
{
IType typeId2 = XamlTypeHelper.GetTypeId(parserContext, lineInformation, xmlNamespaceResolver, extensionArgument, true);
if (typeId2 != null)
{
return((DocumentNode)parserContext.DocumentContext.CreateNode(parserContext.PlatformMetadata.KnownTypes.Type, (IDocumentNodeValue) new DocumentNodeMemberValue((IMember)typeId2)));
}
}
}
else if (parserContext.PlatformMetadata.KnownTypes.StaticExtension.IsAssignableFrom((ITypeId)typeId1))
{
string extensionArgument = MarkupExtensionParser.GetRequiredMarkupExtensionArgument(parserContext, lineInformation, description, parserContext.PlatformMetadata.KnownProperties.StaticExtensionMember.Name);
if (extensionArgument != null)
{
IType typeId2;
string memberName;
if (MarkupExtensionParser.GetTypeAndMemberName(parserContext, lineInformation, xmlNamespaceResolver, extensionArgument, (IType)null, out typeId2, out memberName))
{
MemberAccessTypes allowableMemberAccess = TypeHelper.GetAllowableMemberAccess(parserContext.TypeResolver, typeId2);
MemberType memberTypes = MemberType.LocalProperty | MemberType.Field;
if (parserContext.TypeResolver.IsCapabilitySet(PlatformCapability.IncompleteAttachedPropertiesInMarkupExtensions))
{
memberTypes |= MemberType.IncompleteAttachedProperty;
}
IMember memberId = (IMember)typeId2.GetMember(memberTypes, memberName, allowableMemberAccess) ?? XamlTypeHelper.AddMemberIfPossible(parserContext.PlatformMetadata, typeId2, MemberType.LocalProperty, memberName);
if (memberId != null)
{
return((DocumentNode)DocumentNodeHelper.NewStaticNode(parserContext.DocumentContext, memberId));
}
parserContext.ReportError(XamlParseErrors.UnrecognizedOrInaccessibleMember(lineInformation, memberName));
}
return((DocumentNode)null);
}
}
else
{
if (!parserContext.TypeResolver.PlatformMetadata.KnownTypes.Binding.Equals((object)typeId1) || description.PositionalArguments.Count != 1)
{
return(MarkupExtensionParser.ParseMarkupExtension(parserContext, lineInformation, nodeReference, xmlNamespaceResolver, typeId1, description));
}
description.NamedArguments.Insert(0, new KeyValuePair <string, string>(parserContext.TypeResolver.PlatformMetadata.KnownProperties.BindingPath.Name, description.PositionalArguments[0]));
description.PositionalArguments.Clear();
return(MarkupExtensionParser.ParseMarkupExtension(parserContext, lineInformation, nodeReference, xmlNamespaceResolver, typeId1, description));
}
}
}
return((DocumentNode)null);
}
