private bool CopyItem(ResourceEntryItem primaryResource, ResourceContainer destinationContainer, int destinationIndex, bool skipReferencedResourceCopy)
{
ResourceConflictResolution conflictResolution = ResourceConflictResolution.UseExisting;
DocumentNode node1 = primaryResource.Resource.ResourceNode.Clone(destinationContainer.ViewModel.Document.DocumentContext);
DictionaryEntryNode primaryResource1 = (DictionaryEntryNode)destinationContainer.ViewModel.GetSceneNode(node1);
ResourceEvaluation resourceEvaluation = Microsoft.Expression.DesignSurface.Utility.ResourceHelper.EvaluateResource(primaryResource1, destinationContainer.Node);
List <DictionaryEntryNode> list1 = new List <DictionaryEntryNode>();
if (!skipReferencedResourceCopy)
{
List <DocumentNode> foundResources = new List <DocumentNode>();
Microsoft.Expression.DesignSurface.Utility.ResourceHelper.FindAllReferencedResources(primaryResource.DocumentNode, foundResources, (Microsoft.Expression.DesignSurface.Utility.ResourceHelper.PostOrderOperation)null);
foreach (DocumentNode documentNode in foundResources)
{
DocumentNode node2 = documentNode.Parent.Clone(destinationContainer.ViewModel.Document.DocumentContext);
list1.Add((DictionaryEntryNode)destinationContainer.ViewModel.GetSceneNode(node2));
}
}
IList <ResourceEvaluation> list2 = Microsoft.Expression.DesignSurface.Utility.ResourceHelper.EvaluateResources((IList <DictionaryEntryNode>)list1, destinationContainer.Node);
if (!Microsoft.Expression.DesignSurface.Utility.ResourceHelper.CheckEvaluationResults(list2, (ResourceEvaluationResult)7))
{
if (!Microsoft.Expression.DesignSurface.Utility.ResourceHelper.CheckEvaluationResult(resourceEvaluation, ResourceEvaluationResult.ConflictingResourceExists, ResourceEvaluationResult.IdenticalResourceExists))
{
goto label_10;
}
}
conflictResolution = Microsoft.Expression.DesignSurface.Utility.ResourceHelper.PromptForResourceConflictResolution(ResourceConflictResolution.UseExisting | ResourceConflictResolution.RenameNew | ResourceConflictResolution.OverwriteOld);
if (conflictResolution == ResourceConflictResolution.Undetermined)
{
return(false);
}
label_10:
using (SceneEditTransaction editTransaction = destinationContainer.ViewModel.CreateEditTransaction(StringTable.UndoUnitCopyResource))
{
int num = Microsoft.Expression.DesignSurface.Utility.ResourceHelper.AddResources(list2, (IList <SceneNode>)null, conflictResolution, destinationContainer.Node, destinationIndex);
Microsoft.Expression.DesignSurface.Utility.ResourceHelper.AddPrimaryResource(resourceEvaluation, (IList <SceneNode>)null, conflictResolution, destinationContainer.Node, destinationIndex + num);
ExpressionEvaluator expressionEvaluator = new ExpressionEvaluator(destinationContainer.ViewModel.DocumentRootResolver);
SceneNode keyNode = primaryResource1.KeyNode;
if (keyNode != null)
{
DocumentNode documentNode = expressionEvaluator.EvaluateResource(destinationContainer.Node.DocumentNodePath, keyNode.DocumentNode);
foreach (DictionaryEntryNode dictionaryEntryNode in destinationContainer.ResourceDictionaryNode)
{
if (dictionaryEntryNode.Value.DocumentNode == documentNode)
{
this.ResourceManager.SelectedItems.SetSelection((ResourceEntryBase)this.ResourceManager.GetResourceItem(destinationContainer, dictionaryEntryNode.DocumentNode as DocumentCompositeNode));
editTransaction.Commit();
return(true);
}
}
}
else
{
editTransaction.Commit();
return(true);
}
}
return(false);
}
public ResourceConflictResolutionDialog(ResourceConflictResolution itemsToDisplay)
{
this.InitializeComponent();
this.tbDiscard.IsEnabled = (itemsToDisplay & ResourceConflictResolution.UseExisting) == ResourceConflictResolution.UseExisting;
this.radioDiscard.IsEnabled = (itemsToDisplay & ResourceConflictResolution.UseExisting) == ResourceConflictResolution.UseExisting;
this.tbOverwrite.IsEnabled = (itemsToDisplay & ResourceConflictResolution.OverwriteOld) == ResourceConflictResolution.OverwriteOld;
this.radioOverwrite.IsEnabled = (itemsToDisplay & ResourceConflictResolution.OverwriteOld) == ResourceConflictResolution.OverwriteOld;
this.tbAdd.IsEnabled = (itemsToDisplay & ResourceConflictResolution.RenameNew) == ResourceConflictResolution.RenameNew;
this.radioAdd.IsEnabled = (itemsToDisplay & ResourceConflictResolution.RenameNew) == ResourceConflictResolution.RenameNew;
this.Title = StringTable.ResourceConflictResolutionDialogTitle;
}
internal static ResourceConflictResolution PromptForResourceConflictResolution(ResourceConflictResolution itemsToDisplay)
{
ResourceConflictResolution conflictResolution = ResourceConflictResolution.Undetermined;
ResourceConflictResolutionDialog resolutionDialog = new ResourceConflictResolutionDialog(itemsToDisplay);
if (resolutionDialog.ShowDialog().GetValueOrDefault(false))
{
conflictResolution = resolutionDialog.Resolution;
}
return(conflictResolution);
}
internal static bool PasteResources(PastePackage pastePackage, IDictionary <DocumentNode, string> imageMap, ResourceConflictResolution itemsToDisplay, SceneNode destination, int index, bool lastResourceIsPrimary)
{
SceneViewModel viewModel = destination.ViewModel;
List <DictionaryEntryNode> list1 = new List <DictionaryEntryNode>((IEnumerable <DictionaryEntryNode>)pastePackage.Resources);
if (list1.Count == 0)
{
return(true);
}
bool flag = true;
IList <ResourceEvaluation> list2 = ResourceHelper.EvaluateResources((IList <DictionaryEntryNode>)list1, destination);
ResourceConflictResolution conflictResolution = ResourceConflictResolution.Undetermined;
if (ResourceHelper.CheckEvaluationResults(list2, ResourceEvaluationResult.ConflictingResourceExists, ResourceEvaluationResult.ConflictingResourceIsMasked))
{
conflictResolution = ResourceHelper.PromptForResourceConflictResolution(itemsToDisplay);
if (conflictResolution == ResourceConflictResolution.Undetermined)
{
flag = false;
}
}
if (flag)
{
foreach (ResourceEvaluation resourceEvaluation in (IEnumerable <ResourceEvaluation>)list2)
{
ResourceHelper.UpdateImageReferences(resourceEvaluation.OriginalResource.Value.DocumentNode, imageMap, pastePackage, viewModel);
}
List <SceneNode> list3 = new List <SceneNode>(pastePackage.Elements.Count);
foreach (SceneElement sceneElement in pastePackage.Elements)
{
list3.Add((SceneNode)sceneElement);
}
ResourceEvaluation resourceEvaluation1 = list2[list2.Count - 1];
if (lastResourceIsPrimary)
{
list2.RemoveAt(list2.Count - 1);
int num = ResourceHelper.AddResources(list2, (IList <SceneNode>)list3, conflictResolution, destination, index);
if (ResourceHelper.CheckEvaluationResult(resourceEvaluation1, ResourceEvaluationResult.IdenticalResourceExists))
{
conflictResolution = ResourceConflictResolution.RenameNew;
}
ResourceHelper.AddPrimaryResource(resourceEvaluation1, (IList <SceneNode>)list3, conflictResolution, destination, index + num);
}
else
{
ResourceHelper.AddResources(list2, (IList <SceneNode>)list3, conflictResolution, destination, index);
}
}
return(flag);
}
internal static bool CopyResourcesToNewResourceSite(IList <DocumentCompositeNode> auxillaryResources, SceneViewModel resourcesHostViewModel, DocumentCompositeNode resourcesHostNode, DocumentCompositeNode insertedResourceNode, int indexInResourceSite)
{
if (auxillaryResources == null || auxillaryResources.Count <= 0)
{
return(true);
}
bool flag = true;
ResourceConflictResolution conflictResolution = ResourceConflictResolution.Undetermined;
SceneNode sceneNode = resourcesHostViewModel.GetSceneNode((DocumentNode)resourcesHostNode);
List <DictionaryEntryNode> list1 = new List <DictionaryEntryNode>();
List <SceneNode> list2 = new List <SceneNode>();
foreach (DocumentNode documentNode in (IEnumerable <DocumentCompositeNode>)auxillaryResources)
{
DocumentNode node = documentNode.Clone(resourcesHostViewModel.Document.DocumentContext);
DictionaryEntryNode dictionaryEntryNode = (DictionaryEntryNode)resourcesHostViewModel.GetSceneNode(node);
list1.Add(dictionaryEntryNode);
if (dictionaryEntryNode.Value != null)
{
list2.Add(dictionaryEntryNode.Value);
}
}
if (insertedResourceNode != null)
{
list2.Add(resourcesHostViewModel.GetSceneNode((DocumentNode)insertedResourceNode));
}
IList <ResourceEvaluation> list3 = ResourceHelper.EvaluateResources((IList <DictionaryEntryNode>)list1, sceneNode);
if (ResourceHelper.CheckEvaluationResults(list3, ResourceEvaluationResult.ConflictingResourceExists, ResourceEvaluationResult.ConflictingResourceIsMasked))
{
conflictResolution = ResourceHelper.PromptForResourceConflictResolution(ResourceConflictResolution.RenameNew | ResourceConflictResolution.OverwriteOld);
if (conflictResolution == ResourceConflictResolution.Undetermined)
{
flag = false;
}
}
if (flag)
{
ResourceHelper.EnsureResourceDictionaryNode(sceneNode);
ResourceHelper.AddResources(list3, (IList <SceneNode>)list2, conflictResolution, sceneNode, indexInResourceSite);
}
return(flag);
}
private void HandleOverwriteOld(object sender, EventArgs e)
{
this.Resolution = ResourceConflictResolution.OverwriteOld;
}
private void HandleRenameNew(object sender, EventArgs e)
{
this.Resolution = ResourceConflictResolution.RenameNew;
}
private void HandleUseExisting(object sender, EventArgs e)
{
this.Resolution = ResourceConflictResolution.UseExisting;
}
internal static void AddPrimaryResource(ResourceEvaluation evaluatedPrimaryResource, IList <SceneNode> referringElements, ResourceConflictResolution conflictResolution, SceneNode destination, int insertionIndex)
{
SceneViewModel viewModel = destination.ViewModel;
ResourceDictionaryNode destinationDictionary = ResourceHelper.EnsureResourceDictionaryNode(destination);
DictionaryEntryNode resourceToAdd;
switch (evaluatedPrimaryResource.ConflictType)
{
case ResourceEvaluationResult.NoExistingResource:
resourceToAdd = evaluatedPrimaryResource.OriginalResource;
break;
case ResourceEvaluationResult.IdenticalResourceExists:
resourceToAdd = ResourceHelper.ResolveResourceConflict(evaluatedPrimaryResource, referringElements, destination, conflictResolution);
break;
case ResourceEvaluationResult.IdenticalResourceIsMasked:
resourceToAdd = evaluatedPrimaryResource.OriginalResource;
break;
case ResourceEvaluationResult.ConflictingResourceExists:
resourceToAdd = ResourceHelper.ResolveResourceConflict(evaluatedPrimaryResource, referringElements, destination, conflictResolution);
break;
case ResourceEvaluationResult.ConflictingResourceIsMasked:
resourceToAdd = evaluatedPrimaryResource.OriginalResource;
break;
default:
throw new InvalidEnumArgumentException("ConflictType", (int)evaluatedPrimaryResource.ConflictType, typeof(ResourceEvaluationResult));
}
if (resourceToAdd == null)
{
return;
}
ResourceHelper.AddResource(resourceToAdd, destinationDictionary, insertionIndex);
}
private static DictionaryEntryNode ResolveResourceConflict(ResourceEvaluation resourceEvaluation, IList <SceneNode> elements, SceneNode destination, ResourceConflictResolution resolution)
{
DictionaryEntryNode originalResource = resourceEvaluation.OriginalResource;
DocumentNode evaluatedResource = resourceEvaluation.EvaluatedResource;
DictionaryEntryNode dictionaryEntryNode = (DictionaryEntryNode)null;
if (resolution == ResourceConflictResolution.RenameNew)
{
DocumentNode newKey = ResourceHelper.GenerateUniqueResourceKey(originalResource.Key.ToString(), destination);
ResourceHelper.ChangeKey(elements, originalResource, originalResource.KeyNode.DocumentNode, newKey);
dictionaryEntryNode = originalResource;
}
else if (resolution == ResourceConflictResolution.OverwriteOld)
{
DocumentCompositeNode parent = evaluatedResource.Parent;
if (parent != null && typeof(DictionaryEntry).IsAssignableFrom(parent.TargetType))
{
SceneViewModel viewModel = SceneViewModel.GetViewModel((ISceneViewHost)destination.ProjectContext.GetService(typeof(ISceneViewHost)), parent.DocumentRoot, false);
if (viewModel != null)
{
using (SceneEditTransaction editTransaction = viewModel.CreateEditTransaction(StringTable.UndoResourceOverwrite))
{
((DictionaryEntryNode)viewModel.GetSceneNode((DocumentNode)parent)).Value = viewModel.GetSceneNode(originalResource.Value.DocumentNode.Clone(viewModel.Document.DocumentContext));
editTransaction.Commit();
}
}
}
dictionaryEntryNode = (DictionaryEntryNode)null;
}
else if (resolution == ResourceConflictResolution.UseExisting)
{
dictionaryEntryNode = (DictionaryEntryNode)null;
}
return(dictionaryEntryNode);
}
internal static int AddResources(IList <ResourceEvaluation> referencedResources, IList <SceneNode> referringElements, ResourceConflictResolution conflictResolution, SceneNode destination, int insertionIndex)
{
SceneViewModel viewModel = destination.ViewModel;
ResourceDictionaryNode destinationDictionary = ResourceHelper.EnsureResourceDictionaryNode(destination);
int num = insertionIndex;
foreach (ResourceEvaluation resourceEvaluation in (IEnumerable <ResourceEvaluation>)referencedResources)
{
DictionaryEntryNode resourceToAdd = (DictionaryEntryNode)null;
switch (resourceEvaluation.ConflictType)
{
case ResourceEvaluationResult.NoExistingResource:
resourceToAdd = resourceEvaluation.OriginalResource;
goto case 1;
case ResourceEvaluationResult.IdenticalResourceExists:
case ResourceEvaluationResult.IdenticalResourceIsMasked:
if (resourceToAdd != null)
{
ResourceHelper.AddResource(resourceToAdd, destinationDictionary, insertionIndex);
++insertionIndex;
continue;
}
continue;
case ResourceEvaluationResult.ConflictingResourceExists:
resourceToAdd = ResourceHelper.ResolveResourceConflict(resourceEvaluation, referringElements, destination, conflictResolution);
goto case 1;
case ResourceEvaluationResult.ConflictingResourceIsMasked:
resourceToAdd = ResourceHelper.ResolveResourceConflict(resourceEvaluation, referringElements, destination, conflictResolution);
goto case 1;
default:
throw new InvalidEnumArgumentException("ConflictType", (int)resourceEvaluation.ConflictType, typeof(ResourceEvaluationResult));
}
}
return(insertionIndex - num);
}