private static IList <ResourceEvaluation> EvaluateResourcesInternal(IList <DictionaryEntryNode> resources, SceneNode destination)
{
SceneViewModel viewModel = destination.ViewModel;
List <ResourceEvaluation> list = new List <ResourceEvaluation>();
foreach (DictionaryEntryNode originalResource in (IEnumerable <DictionaryEntryNode>)resources)
{
DocumentNode documentNode = (DocumentNode)null;
SceneNode keyNode = originalResource.KeyNode;
if (keyNode != null)
{
documentNode = new ExpressionEvaluator(viewModel.DocumentRootResolver).EvaluateResource(destination.DocumentNodePath, keyNode.DocumentNode);
}
if (documentNode == null)
{
list.Add(new ResourceEvaluation(originalResource, (DocumentNode)null, ResourceEvaluationResult.NoExistingResource));
}
else
{
ISupportsResources resourcesCollection = ResourceNodeHelper.GetResourcesCollection(destination.DocumentNode);
bool flag = resourcesCollection != null && resourcesCollection.Resources == documentNode.Parent.Parent;
if (ResourceHelper.NodeTreesAreEquivalent(viewModel, originalResource.Value.DocumentNode, documentNode))
{
list.Add(new ResourceEvaluation(originalResource, documentNode, flag ? ResourceEvaluationResult.IdenticalResourceExists : ResourceEvaluationResult.IdenticalResourceIsMasked));
}
else
{
list.Add(new ResourceEvaluation(originalResource, documentNode, flag ? ResourceEvaluationResult.ConflictingResourceExists : ResourceEvaluationResult.ConflictingResourceIsMasked));
}
}
}
return((IList <ResourceEvaluation>)list);
}
private void OnViewUpdated(SceneUpdatePhaseEventArgs args)
{
if (this.view != null && this.Document != null && this.Document.IsEditable)
{
ISupportsResources resourcesCollection = ResourceNodeHelper.GetResourcesCollection(this.Document.RootNode);
if (resourcesCollection != null)
{
DocumentNode node = (DocumentNode)resourcesCollection.Resources;
if (node != null)
{
this.resourceSubscription.SetBasisNodes(this.ViewModel, (IEnumerable <SceneNode>) new List <SceneNode>()
{
this.ViewModel.GetSceneNode(node)
});
this.resourceSubscription.Update(this.ViewModel, args.DocumentChanges, args.DocumentChangeStamp);
}
}
}
else
{
this.needsRebuild = true;
this.resourceSubscription.SetBasisNodes(this.ViewModel, (IEnumerable <SceneNode>) new List <SceneNode>());
}
if (!this.needsRebuild)
{
return;
}
this.OnItemsChanged();
}
private DocumentNode EvaluateResourceAtSpecificNode(DocumentNode node, DocumentNode keyNode, ICollection <DocumentCompositeNode> resourcesHostNodePath, ICollection <IDocumentRoot> relatedRoots, ICollection <string> warnings)
{
ISupportsResources resourcesCollection = ResourceNodeHelper.GetResourcesCollection(node);
if (resourcesCollection == null)
{
return(null);
}
ResourceSite resourceSite = new ResourceSite(node.Context, resourcesCollection);
return(this.EvaluateResourceAtSpecificSite(resourceSite, keyNode, resourcesHostNodePath, relatedRoots, -1, warnings));
}
public ResourceSite(IDocumentContext documentContext, ISupportsResources resourcesHost)
{
if (documentContext == null)
{
throw new ArgumentNullException("documentContext");
}
if (resourcesHost == null)
{
throw new ArgumentNullException("resourcesHost");
}
this.documentContext = documentContext;
this.resourcesHost = resourcesHost;
}
public static bool IsResourceContainer(ISupportsResources value, DocumentNode childNode)
{
ResourceNodeHelper.ResourceContainerAdapter resourceContainerAdapter = value as ResourceNodeHelper.ResourceContainerAdapter;
if (resourceContainerAdapter == null)
{
return(false);
}
if (childNode == null)
{
return(true);
}
return(!resourceContainerAdapter.ResourcesProperty.Equals(childNode.SitePropertyKey));
}
private static bool SearchForAnimationsInResources(DocumentCompositeNode elementNode, DocumentNode pathNameNode)
{
bool flag;
DocumentCompositeNode resources = null;
ISupportsResources resourcesCollection = ResourceNodeHelper.GetResourcesCollection(elementNode);
if (resourcesCollection != null)
{
resources = resourcesCollection.Resources;
}
if (resources != null)
{
using (IEnumerator <DocumentNode> enumerator = resources.ChildNodes.GetEnumerator())
{
while (enumerator.MoveNext())
{
DocumentCompositeNode current = enumerator.Current as DocumentCompositeNode;
if (current == null)
{
continue;
}
DocumentNode item = current.Properties[KnownProperties.DictionaryEntryValueProperty];
if (item == null || !PlatformTypes.Storyboard.IsAssignableFrom(item.Type))
{
continue;
}
using (IEnumerator <DocumentNode> enumerator1 = item.FindPointAnimationDescendantNodes().GetEnumerator())
{
while (enumerator1.MoveNext())
{
if (!PathGeometrySerializationHelper.DoesAnimationTargetPath(pathNameNode, enumerator1.Current))
{
continue;
}
flag = true;
return(flag);
}
}
}
return(false);
}
return(flag);
}
return(false);
}
private static ICollection <SceneNode> PasteData(SceneViewModel viewModel, SafeDataObject dataObject, ISceneInsertionPoint insertionPoint, bool allowInsertionPointChange, out bool canceledPasteOperation)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.PasteElements);
canceledPasteOperation = false;
List <SceneNode> list = new List <SceneNode>();
PastePackage pastePackage = PastePackage.FromData(viewModel, dataObject);
if (pastePackage != null)
{
if (allowInsertionPointChange)
{
insertionPoint = PasteCommand.ComputeNewInsertionPoint(viewModel, insertionPoint, pastePackage);
}
if (!PasteCommand.CanAddMultipleElements(insertionPoint.SceneElement, pastePackage.Elements.Count))
{
string name = insertionPoint.SceneElement.TargetType.Name;
viewModel.DesignerContext.MessageDisplayService.ShowError(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.PasteMultipleInSingleContainerError, new object[1]
{
(object)name
}));
}
else if (pastePackage.Elements.Count == 0 && pastePackage.Storyboards.Count == 0 && pastePackage.Resources.Count > 0)
{
viewModel.DesignerContext.MessageDisplayService.ShowError(StringTable.PasteElementsFailedNoElementsDialogMessage);
}
else
{
IDictionary <DocumentNode, string> imageMap = (IDictionary <DocumentNode, string>) new Dictionary <DocumentNode, string>();
foreach (SceneNode sceneNode in pastePackage.Elements)
{
foreach (KeyValuePair <DocumentNode, string> keyValuePair in (IEnumerable <KeyValuePair <DocumentNode, string> >)Microsoft.Expression.DesignSurface.Utility.ResourceHelper.CreateImageReferenceMap(sceneNode.DocumentNode, pastePackage, viewModel))
{
imageMap.Add(keyValuePair);
}
}
foreach (SceneNode sceneNode in pastePackage.Resources)
{
foreach (KeyValuePair <DocumentNode, string> keyValuePair in (IEnumerable <KeyValuePair <DocumentNode, string> >)Microsoft.Expression.DesignSurface.Utility.ResourceHelper.CreateImageReferenceMap(sceneNode.DocumentNode, pastePackage, viewModel))
{
imageMap.Add(keyValuePair);
}
}
int index = 0;
ISupportsResources resourcesCollection = ResourceNodeHelper.GetResourcesCollection(viewModel.RootNode.DocumentNode);
if (resourcesCollection != null && resourcesCollection.Resources != null && resourcesCollection.Resources.SupportsChildren)
{
index = resourcesCollection.Resources.Children.Count;
}
if (Microsoft.Expression.DesignSurface.Utility.ResourceHelper.PasteResources(pastePackage, imageMap, ResourceConflictResolution.UseExisting | ResourceConflictResolution.RenameNew | ResourceConflictResolution.OverwriteOld, viewModel.RootNode, index, false))
{
ILayoutDesigner designerForParent = viewModel.GetLayoutDesignerForParent(insertionPoint.SceneElement, true);
List <PasteCommand.DelayedElementTranslationInfo> elementsToTranslateLater = new List <PasteCommand.DelayedElementTranslationInfo>(pastePackage.Elements.Count);
string copyElementToken = pastePackage.ClipboardCopyElementToken;
foreach (SceneElement element in pastePackage.Elements)
{
SceneElement sceneElement = PasteCommand.PasteElement(viewModel, element, elementsToTranslateLater, insertionPoint);
if (sceneElement != null)
{
Microsoft.Expression.DesignSurface.Utility.ResourceHelper.UpdateImageReferences(sceneElement.DocumentNode, imageMap, pastePackage, viewModel);
list.Add((SceneNode)sceneElement);
sceneElement.ClearValue(DesignTimeProperties.CopyTokenProperty);
}
}
if (copyElementToken != null)
{
pastePackage.SetGlobalCopyElementToken(copyElementToken);
PastePackage.PasteSelectionChangePending = true;
}
foreach (SceneNode childProperty in pastePackage.ChildPropertyNodes)
{
PasteCommand.PasteChildProperty(viewModel, childProperty, (IList <SceneNode>)list);
}
foreach (StoryboardTimelineSceneNode storyboard in pastePackage.Storyboards)
{
PasteCommand.PasteStoryboard(viewModel, storyboard, (IList <SceneNode>)list);
}
viewModel.Document.OnUpdatedEditTransaction();
viewModel.DefaultView.UpdateLayout();
using (viewModel.ForceBaseValue())
{
Rect empty = Rect.Empty;
foreach (PasteCommand.DelayedElementTranslationInfo elementTranslationInfo in elementsToTranslateLater)
{
empty.Union(elementTranslationInfo.Bounds);
}
foreach (PasteCommand.DelayedElementTranslationInfo elementTranslationInfo in elementsToTranslateLater)
{
elementTranslationInfo.UpdateTranslation(designerForParent, empty);
}
}
}
else
{
canceledPasteOperation = true;
}
}
}
else if (dataObject.GetDataPresent(DataFormats.FileDrop))
{
DesignerContext designerContext = viewModel.DesignerContext;
string[] supportedFiles = FileDropToolBehavior.CreateImageOrMediaDrop(designerContext).GetSupportedFiles(ClipboardService.GetDataObject());
if (supportedFiles.Length > 0)
{
IEnumerable <IProjectItem> importedItems = designerContext.ActiveProject.AddItems(Enumerable.Select <string, DocumentCreationInfo>((IEnumerable <string>)supportedFiles, (Func <string, DocumentCreationInfo>)(file => new DocumentCreationInfo()
{
SourcePath = file
})));
FileDropToolBehavior.AddItemsToDocument(viewModel.DefaultView, importedItems, new Point(0.0, 0.0), viewModel.ActiveSceneInsertionPoint);
}
else
{
viewModel.DesignerContext.MessageDisplayService.ShowError(StringTable.PasteElementsFailedDialogMessage);
}
}
else if (dataObject.GetDataPresent(DataFormats.Bitmap))
{
DesignerContext designerContext = viewModel.DesignerContext;
IProjectItem projectItem = CutBuffer.AddImageDataFromClipboard(designerContext.ProjectManager, designerContext.ActiveProject);
if (projectItem != null)
{
FileDropToolBehavior.AddItemsToDocument(viewModel.DefaultView, (IEnumerable <IProjectItem>) new List <IProjectItem>()
{
projectItem
}, new Point(0.0, 0.0), viewModel.ActiveSceneInsertionPoint);
}
else
{
viewModel.DesignerContext.MessageDisplayService.ShowError(StringTable.PasteElementsFailedDialogMessage);
}
}
else
{
viewModel.DesignerContext.MessageDisplayService.ShowError(StringTable.PasteElementsFailedDialogMessage);
}
return((ICollection <SceneNode>)list);
}
public static bool IsResourceDictionary(ISupportsResources value)
{
return(value is ResourceNodeHelper.ResourceDictionaryAdapter);
}
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);
}
