public DocumentNode GetThemeResourceFromAssembly(IProjectContext projectContext, IAssembly themeRuntimeAssembly, IAssembly themeTargetAssembly, object resourceKey, out IList <DocumentCompositeNode> auxillaryResources)
{
using (TemporaryCursor.SetWaitCursor())
{
foreach (string str1 in ThemeContentProvider.GetThemeNames(projectContext))
{
string str2 = string.Format((IFormatProvider)CultureInfo.InvariantCulture, "themes/{0}.xaml", new object[1]
{
(object)str1.ToLowerInvariant()
});
IProjectContext projectContext1 = (IProjectContext) new ThemeContentProvider.TargetThemeAssemblyProjectContext(projectContext, themeRuntimeAssembly, this.designerContext.AssemblyService);
DocumentReference theme = DocumentReference.Create(Path.Combine(themeTargetAssembly.Name, str2));
DocumentNode resourceInternal = this.GetResourceInternal(this.projectThemeCache, projectContext.Platform.ThemeManager, projectContext1, theme, themeTargetAssembly, str2, resourceKey, out auxillaryResources);
if (resourceInternal != null)
{
return(resourceInternal);
}
}
if (projectContext.Platform.ThemeManager.AllowFallbackToPlatform)
{
return(this.GetThemeResourceFromPlatform(projectContext.Platform, resourceKey, out auxillaryResources));
}
auxillaryResources = (IList <DocumentCompositeNode>)null;
return((DocumentNode)null);
}
}
private void Cleanup(bool cleanSupportingFolderIfNotInProject)
{
if (this.temporaryFolderPlaceholder != null)
{
this.temporaryFolderPlaceholder.Dispose();
this.temporaryFolderPlaceholder = (ProjectPathHelper.TemporaryDirectory)null;
}
if (this.supportingDirectoryPath != null && cleanSupportingFolderIfNotInProject)
{
if (this.ImportContext.ActiveProject.FindItem(DocumentReference.Create(this.supportingDirectoryPath)) == null)
{
try
{
Directory.Delete(this.supportingDirectoryPath);
}
catch (IOException ex)
{
}
}
}
IDisposable disposable = this.asyncHandlerArgument as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
this.asyncHandlerArgument = (object)null;
}
private void PerformPartialCompile(IProjectItem xamlProjectItem)
{
if (this.lastDirtyStateBeforePartialCompileIndex.ContainsKey(xamlProjectItem.DocumentReference) && xamlProjectItem.Document != null)
{
CodeProject.PartialCompileDirtyState compileDirtyState = new CodeProject.PartialCompileDirtyState()
{
DirtyState = xamlProjectItem.Document.IsDirty,
PartialCompileTime = DateTime.UtcNow
};
this.lastDirtyStateBeforePartialCompileIndex[xamlProjectItem.DocumentReference] = new CodeProject.PartialCompileDirtyState?(compileDirtyState);
}
string fileName = DocumentReference.Create(Microsoft.Expression.Framework.Documents.PathHelper.GetDirectoryNameOrRoot(this.project.DocumentReference.Path)).GetRelativePath(xamlProjectItem.DocumentReference);
foreach (char oldChar in Microsoft.Expression.Framework.Documents.PathHelper.GetDirectorySeparatorCharacters())
{
fileName = fileName.Replace(oldChar, '_');
}
string documentText = this.GetDocumentText(xamlProjectItem);
if (documentText == null)
{
return;
}
PartialXamlBuilder partialXamlBuilder = new PartialXamlBuilder(this.project, xamlProjectItem, documentText, fileName, this.buildManager);
partialXamlBuilder.BuildFinished += new EventHandler <PartialXamlBuildFinishedEventArgs>(this.XamlBuilder_BuildFinished);
partialXamlBuilder.Build();
}
private void SafelyRemoveSampleDataAndRootFolder(SampleDataSet dataSet, bool forceDeleteFiles)
{
dataSet.Close();
if (forceDeleteFiles)
{
SampleDataCollection.DeleteFolder(dataSet.SampleDataFolder, false);
}
else
{
SampleDataCollection.DeleteFolder(dataSet.AssetFilesFolder, true);
SampleDataCollection.DeleteFolder(dataSet.SampleDataFolder, true);
}
this.OnSampleDataRemoving(dataSet);
this.dataSets.Remove(dataSet);
if (Enumerable.FirstOrDefault <SampleDataSet>(Enumerable.Where <SampleDataSet>((IEnumerable <SampleDataSet>) this.dataSets, (Func <SampleDataSet, bool>)(item => item.Context == dataSet.Context))) != null)
{
return;
}
string path = Path.Combine(Path.GetDirectoryName(this.projectContext.ProjectPath), dataSet.Context.DataRootFolder);
IProject project = (IProject)this.projectContext.GetService(typeof(IProject));
IProjectItem projectItem = project.FindItem(DocumentReference.Create(path));
if (projectItem == null || Enumerable.FirstOrDefault <IProjectItem>(projectItem.Children) != null)
{
return;
}
project.RemoveItems(0 != 0, projectItem);
SampleDataCollection.DeleteFolder(dataSet.Context.DataRootFolder, true);
}
public string MakeSourceReference(string fullPath)
{
DocumentReference reference = DocumentReference.Create(fullPath);
if (this.sceneViewModel != null)
{
string str = this.sceneViewModel.Document.DocumentReference.GetRelativePath(reference);
if (str != null && this.sceneViewModel.ProjectContext.IsCapabilitySet(PlatformCapability.ShouldSanitizeResourceReferences))
{
str = str.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
}
return(str);
}
string str1 = this.ActiveProject.DocumentReference.GetRelativePath(reference);
if (str1 == null)
{
return((string)null);
}
IXamlProject xamlProject = this.ActiveProject as IXamlProject;
if (xamlProject != null)
{
ITypeResolver typeResolver = (ITypeResolver)ProjectContext.GetProjectContext(xamlProject.ProjectContext);
if (typeResolver != null && typeResolver.IsCapabilitySet(PlatformCapability.ShouldSanitizeResourceReferences))
{
str1 = str1.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
}
}
return(str1);
}
public override void Execute()
{
string project = this.Project;
if (!string.IsNullOrEmpty(project))
{
if (PathHelper.FileExists(project) || PathHelper.DirectoryExists(project))
{
if (this.Solution() != null && this.Solution().DocumentReference.Path == project)
{
return;
}
if (this.ProjectManager().CloseSolution())
{
this.ProjectManager().OpenSolution(DocumentReference.Create(project), true, true);
}
}
else
{
MessageBoxArgs messageBoxArg = new MessageBoxArgs();
CultureInfo currentCulture = CultureInfo.CurrentCulture;
string openRecentProjectNotFoundDialogMessage = StringTable.OpenRecentProjectNotFoundDialogMessage;
object[] objArray = new object[] { project };
messageBoxArg.Message = string.Format(currentCulture, openRecentProjectNotFoundDialogMessage, objArray);
messageBoxArg.Button = MessageBoxButton.YesNo;
messageBoxArg.Image = MessageBoxImage.Hand;
if (base.Services.MessageDisplayService().ShowMessage(messageBoxArg) == MessageBoxResult.Yes)
{
((ProjectManager)this.ProjectManager()).RemoveRecentProject(project);
return;
}
}
}
}
private static string AdjustTargetFolder(string targetFolder, string rootSourcePath, string fullSourcePath)
{
string directoryNameOrRoot = Microsoft.Expression.Framework.Documents.PathHelper.GetDirectoryNameOrRoot(fullSourcePath);
DocumentReference documentReference = DocumentReference.Create(rootSourcePath);
DocumentReference documentReference1 = DocumentReference.Create(directoryNameOrRoot);
return(Microsoft.Expression.Framework.Documents.PathHelper.ResolveCombinedPath(targetFolder, documentReference.GetRelativePath(documentReference1)));
}
public static DesignDataMode GetDesignDataMode(IProject project, string path)
{
if (project == null || string.IsNullOrEmpty(path))
{
return(DesignDataMode.None);
}
return(DocumentContextHelper.GetDesignDataMode(project.FindItem(DocumentReference.Create(path))));
}
private IProjectItem FindItemRelative(string projectRelativeItemName)
{
IProjectItem projectItem = (IProjectItem)null;
if (projectRelativeItemName != null)
{
projectItem = this.FindItem(DocumentReference.Create(Path.Combine(this.ProjectRoot.Path, projectRelativeItemName)));
}
return(projectItem);
}
private string GetSupportingDirectory(string supportingFolderName, bool create)
{
string importDirectoryPath = this.ImportDirectoryPath;
string path1 = Path.Combine(importDirectoryPath, supportingFolderName);
IProject activeProject = this.importContext.ActiveProject;
if (activeProject == null)
{
return((string)null);
}
if (this.supportingFolderName == null)
{
DocumentReference documentReference = DocumentReference.Create(path1);
if (activeProject.FindItem(documentReference) != null)
{
string str1 = ProjectPathHelper.GetAvailableFilePath(supportingFolderName, importDirectoryPath, activeProject, true).Substring(importDirectoryPath.Length).Trim(Path.DirectorySeparatorChar);
string str2 = string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.ImportImageDirectoryOverwriteDialogMessage, new object[2]
{
(object)supportingFolderName,
(object)str1
});
Dictionary <MessageChoice, string> dictionary = new Dictionary <MessageChoice, string>();
dictionary[MessageChoice.Yes] = StringTable.ImportImageDirectoryOverwriteDialogMessageYesButtonCaption;
dictionary[MessageChoice.No] = StringTable.ImportImageDirectoryOverwriteDialogMessageNoButtonCaption;
switch (this.messageDisplayService.ShowMessage(new MessageBoxArgs()
{
Message = str2,
Button = MessageBoxButton.YesNoCancel,
Image = MessageBoxImage.Exclamation,
TextOverrides = (IDictionary <MessageChoice, string>)dictionary
}))
{
case MessageBoxResult.Yes:
supportingFolderName = str1;
break;
case MessageBoxResult.No:
break;
default:
throw new OperationCanceledException();
}
}
this.supportingFolderName = supportingFolderName;
}
string path2 = Path.Combine(importDirectoryPath, this.supportingFolderName);
if (!Microsoft.Expression.Framework.Documents.PathHelper.DirectoryExists(path2) && create)
{
Directory.CreateDirectory(path2);
}
this.supportingDirectoryPath = path2;
return(this.supportingFolderName);
}
private string GetRelativePathForDocumentReference(DocumentReference referencingDocument)
{
string str = this.resourceItem.ProjectRelativeDocumentReference.TrimStart(Microsoft.Expression.Framework.Documents.PathHelper.GetDirectorySeparatorCharacters());
DocumentReference documentReference = null;
if (!Microsoft.Expression.Framework.Documents.PathHelper.IsValidPath(str))
{
return(null);
}
documentReference = DocumentReference.Create(Microsoft.Expression.Framework.Documents.PathHelper.ResolveCombinedPath(this.resourceItem.Project.ProjectRoot.Path, str));
return(referencingDocument.GetRelativePath(documentReference));
}
public static TDocumentItem FindMatchByUrl <TDocumentItem>(this IEnumerable <TDocumentItem> source, string url)
where TDocumentItem : class, IDocumentItem
{
DocumentReference documentReference = DocumentReference.Create(url);
IIndexedHashSet <TDocumentItem> tDocumentItems = source as IIndexedHashSet <TDocumentItem>;
if (tDocumentItems != null)
{
return(tDocumentItems[documentReference.GetHashCode()]);
}
return(source.FirstOrDefault <TDocumentItem>((TDocumentItem d) => d.DocumentReference.GetHashCode() == documentReference.GetHashCode()));
}
public override void Execute()
{
this.HandleBasicExceptions(() => {
string str = base.SelectProject(this.DisplayName);
if (!string.IsNullOrEmpty(str))
{
IProjectStore projectStore = ProjectStoreHelper.CreateProjectStore(DocumentReference.Create(str), base.Services, ProjectStoreHelper.ResilientProjectCreationChain);
if (projectStore == null)
{
return;
}
UpgradeWizard upgradeWizard = new UpgradeWizard(this.Solution() as ISolutionManagement,
from project in this.Solution().Projects.OfType <ProjectBase>()
select project.ProjectStore, projectStore, null, base.Services);
try
{
if (!upgradeWizard.Upgrade())
{
return;
}
}
finally
{
projectStore.Dispose();
projectStore = null;
}
projectStore = ProjectStoreHelper.CreateProjectStore(DocumentReference.Create(str), base.Services, ProjectStoreHelper.DefaultProjectCreationChain);
if (projectStore == null)
{
return;
}
INamedProject namedProject = null;
try
{
namedProject = this.ProjectManager().AddProject(projectStore);
if (namedProject != null)
{
base.UpdateSourceControl(EnumerableExtensions.AsEnumerable <INamedProject>(namedProject));
base.ActivateProjectPane();
}
}
finally
{
if (namedProject == null && projectStore != null)
{
projectStore.Dispose();
projectStore = null;
}
}
}
});
}
private static bool IsResourceInSameProject(SceneViewModel viewModel, DocumentReference localPath, Uri originalUri)
{
IProject project = ResourceHelper.ProjectFromViewModel(viewModel);
Uri uri = ResourceHelper.DocumentContextFromViewModel(viewModel).MakeDesignTimeUri(originalUri);
if (project.FindItem(localPath) != null)
{
return(true);
}
if (uri != (Uri)null)
{
return(project.FindItem(DocumentReference.Create(uri.OriginalString)) != null);
}
return(false);
}
protected override void InternalExectute()
{
Dictionary <string, string> strs;
IDocumentItem documentItem = this.Selection().SingleOrNull <IDocumentItem>();
if (documentItem != null)
{
if (!this.SaveSolution(true))
{
return;
}
using (IDisposable disposable = this.SuspendWatchers())
{
List <IDocumentItem> list = base.GetFileItemAndDescendants(documentItem).Where <IDocumentItem>(new Func <IDocumentItem, bool>(this.FileHasPendingChange)).ToList <IDocumentItem>();
string[] array = (
from item in list
select item.DocumentReference.Path).ToArray <string>();
base.SourceControlProvider.RevertChange(array, out strs);
foreach (string key in strs.Keys)
{
DocumentReference documentReference = DocumentReference.Create(key);
if (!documentReference.IsValidPathFormat)
{
continue;
}
string directoryNameOrRoot = Microsoft.Expression.Framework.Documents.PathHelper.GetDirectoryNameOrRoot(documentReference);
if (directoryNameOrRoot == null || !Microsoft.Expression.Framework.Documents.PathHelper.DirectoryExists(directoryNameOrRoot))
{
continue;
}
try
{
if (!Directory.EnumerateFiles(directoryNameOrRoot, "*.*", SearchOption.AllDirectories).Any <string>())
{
Directory.Delete(directoryNameOrRoot);
}
}
catch (IOException oException)
{
}
catch (SecurityException securityException)
{
}
}
}
SourceControlStatusCache.UpdateStatus(this.Solution().Descendants.AppendItem <IDocumentItem>(this.Solution()), base.SourceControlProvider);
}
}
public override void Execute()
{
this.HandleBasicExceptions(() => {
string str = base.SelectProject(StringTable.OpenProjectDialogTitle);
if (!string.IsNullOrEmpty(str))
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.OpenProjectInner);
ISolution solution = this.ProjectManager().OpenSolution(DocumentReference.Create(str), true, true);
PerformanceUtility.MarkInterimStep(PerformanceEvent.OpenProjectInner, "Finished loading, now closing all projects.");
if (solution != null)
{
this.ProjectManager().DefaultOpenProjectPath = Path.GetDirectoryName(Path.GetDirectoryName(solution.DocumentReference.Path));
}
}
});
}
private bool HandleCanProcessCommandLineArgs(string[] args)
{
string[] arguments = this.commandLineService.GetArguments(string.Empty, args);
bool flag = false;
if (arguments != null)
{
if (arguments.Length == 1)
{
try
{
string fullPath = Path.GetFullPath(arguments[0]);
if (Microsoft.Expression.Framework.Documents.PathHelper.FileOrDirectoryExists(fullPath))
{
DocumentReference documentReference = DocumentReference.Create(fullPath);
if (this.projectManager.CurrentSolution == null || this.projectManager.CurrentSolution.DocumentReference.Path.Equals(fullPath, StringComparison.OrdinalIgnoreCase) || this.projectManager.CurrentSolution.FindProject(documentReference) != null)
{
flag = true;
}
else
{
foreach (IProject project in this.projectManager.CurrentSolution.Projects)
{
if (project.FindItem(documentReference) != null)
{
flag = true;
break;
}
}
}
}
}
catch (Exception ex)
{
if (!ErrorHandling.ShouldHandleExceptions(ex))
{
throw;
}
else
{
flag = false;
}
}
}
}
return(flag);
}
public void AddLicensedItem(string projectPath, string typeName, string assemblyName)
{
IProject matchByUrl = DocumentItemExtensions.FindMatchByUrl <IProject>(this.context.ProjectManager.CurrentSolution.Projects, projectPath);
List <string> list = new List <string>();
string path = Path.Combine(matchByUrl.ProjectRoot.Path, "Properties\\Licenses.licx");
if (matchByUrl.FindItem(DocumentReference.Create(path)) == null)
{
IDocumentType documentType = this.context.DocumentTypeManager.DocumentTypes[DocumentTypeNamesHelper.Licx];
matchByUrl.AddItem(new DocumentCreationInfo()
{
DocumentType = documentType,
TargetPath = path
});
}
else if (Microsoft.Expression.Framework.Documents.PathHelper.FileExists(path))
{
using (StreamReader streamReader = File.OpenText(path))
{
while (!streamReader.EndOfStream)
{
list.Add(streamReader.ReadLine());
}
}
}
string str1 = typeName + ", " + assemblyName;
if (list.Contains(str1))
{
return;
}
list.Add(str1);
string directoryName = Path.GetDirectoryName(path);
if (!Microsoft.Expression.Framework.Documents.PathHelper.DirectoryExists(directoryName))
{
Directory.CreateDirectory(directoryName);
}
using (StreamWriter text = File.CreateText(path))
{
foreach (string str2 in list)
{
text.WriteLine(str2);
}
}
}
private void OpenExistingSample(string path, IProjectTemplate sampleTemplate, IProjectManager projectManager)
{
try
{
this.dialogWindow.Opacity = 0.0;
UIThreadDispatcher.Instance.DoEvents();
if (!sampleTemplate.HasProjectFile)
{
if (projectManager.OpenSolution(DocumentReference.Create(path), false, true) == null)
{
return;
}
this.dialogWindow.Close();
}
else
{
string projectFilename = sampleTemplate.ProjectFilename;
string path1 = (string)null;
if (!string.IsNullOrEmpty(projectFilename))
{
string[] strArray = (string[])null;
try
{
strArray = Directory.GetFiles(path, projectFilename, SearchOption.AllDirectories);
}
catch (DirectoryNotFoundException ex)
{
}
if (strArray != null && strArray.Length != 0)
{
path1 = strArray[0];
}
}
if (string.IsNullOrEmpty(path1) || !Microsoft.Expression.Framework.Documents.PathHelper.FileExists(path1) || projectManager.OpenSolution(DocumentReference.Create(path1), false, true) == null)
{
return;
}
this.dialogWindow.Close();
}
}
finally
{
this.dialogWindow.Opacity = 1.0;
}
}
private DocumentReference DetermineOutOfBrowserPrivateLocation(IProject sourceProject, Uri outOfBrowserQueryUri, out string applicationIdentifier)
{
DocumentReference documentReference = (DocumentReference)null;
applicationIdentifier = (string)null;
IXamlProject xamlProject = sourceProject as IXamlProject;
IProjectContext projectContext = xamlProject != null ? xamlProject.ProjectContext : (IProjectContext)null;
if (projectContext != null && projectContext.Platform != null)
{
string deploymentLocation;
applicationIdentifier = projectContext.Platform.GetDeploymentInformation(outOfBrowserQueryUri, out deploymentLocation);
if (deploymentLocation != null)
{
documentReference = DocumentReference.Create(deploymentLocation);
}
}
return(documentReference);
}
private DocumentNode FindProjectResource(IProject project, ResourceDictionaryContentProvider currentThemeProvider, string currentThemePath, object resourceKey, out IList <DocumentCompositeNode> auxillaryResources)
{
List <string> resolvedUris = new List <string>();
return(ThemeContentProvider.FindResource(currentThemeProvider, currentThemePath, (Func <ResourceDictionaryContentProvider, Func <DocumentNode, object> >)(provider => (Func <DocumentNode, object>)(resourceKeyNode =>
{
DocumentNode rootNode = currentThemeProvider.Document.RootNode;
using (StandaloneInstanceBuilderContext instanceBuilderContext = new StandaloneInstanceBuilderContext(rootNode.Context, this.designerContext))
{
using (instanceBuilderContext.DisablePostponedResourceEvaluation())
{
instanceBuilderContext.ViewNodeManager.RootNodePath = new DocumentNodePath(rootNode, resourceKeyNode);
instanceBuilderContext.ViewNodeManager.Instantiate(instanceBuilderContext.ViewNodeManager.Root);
return instanceBuilderContext.ViewNodeManager.ValidRootInstance;
}
}
})), (Func <Uri, string, string>)((relativeUri, sourcePath) =>
{
Uri uri = project.MakeDesignTimeUri(relativeUri, sourcePath);
if (!(uri != (Uri)null))
{
return (string)null;
}
string originalString = uri.OriginalString;
if (resolvedUris.Contains(originalString))
{
return (string)null;
}
resolvedUris.Add(originalString);
return originalString;
}), (Func <string, ResourceDictionaryContentProvider>)(resolvedUri =>
{
if (!string.IsNullOrEmpty(resolvedUri))
{
IProjectItem projectItem = project.FindItem(DocumentReference.Create(resolvedUri));
if (projectItem != null)
{
return this.designerContext.ResourceManager.GetContentProviderForResourceDictionary(projectItem);
}
}
return (ResourceDictionaryContentProvider)null;
}), resourceKey, out auxillaryResources));
}
internal MakeUserControlDialog(DesignerContext designerContext, string dialogTitle, TemplateItemHelper templateItemHelper, string recommendedName)
{
this.InitializeComponent();
this.userControlItem = templateItemHelper.FindTemplateItem("UserControl");
this.designerContext = designerContext;
this.Title = dialogTitle;
this.DataContext = (object)this;
string str1 = designerContext.ProjectManager.TargetFolderForProject(designerContext.ActiveProject);
if (!string.IsNullOrEmpty(recommendedName))
{
string str2 = recommendedName + ".xaml";
DocumentReference documentReference = DocumentReference.Create(Path.Combine(str1, str2));
this.name = designerContext.ActiveProject.FindItem(documentReference) == null ? recommendedName : Path.GetFileNameWithoutExtension(ProjectPathHelper.GetAvailableFilePath(str2, str1, designerContext.ActiveProject));
}
else if (this.userControlItem != null)
{
this.name = Path.GetFileNameWithoutExtension(ProjectPathHelper.GetAvailableFilePath(this.userControlItem.DefaultName, str1, designerContext.ActiveProject));
}
this.controlNameMessageBubble = new MessageBubbleHelper((UIElement)this.Control_Name, (IMessageBubbleValidator) new ProjectItemNameValidator(designerContext.ActiveProject));
}
private static bool HasContentAlreadyBeenMoved(IEnumerable <Microsoft.Expression.Project.MoveInfo> movedDirectories, string fileName)
{
bool flag;
DocumentReference documentReference = DocumentReference.Create(Microsoft.Expression.Framework.Documents.PathHelper.GetDirectoryNameOrRoot(fileName));
using (IEnumerator <Microsoft.Expression.Project.MoveInfo> enumerator = movedDirectories.GetEnumerator())
{
while (enumerator.MoveNext())
{
Microsoft.Expression.Project.MoveInfo current = enumerator.Current;
DocumentReference documentReference1 = DocumentReference.Create(Microsoft.Expression.Framework.Documents.PathHelper.EnsurePathEndsInDirectorySeparator(current.Source));
if (!documentReference.Path.StartsWith(documentReference1.Path, StringComparison.OrdinalIgnoreCase))
{
continue;
}
flag = true;
return(flag);
}
return(false);
}
return(flag);
}
public static IProjectItem GetDesignDataFile(DocumentNode documentNode)
{
IProject project = (IProject)((IServiceProvider)documentNode.TypeResolver).GetService(typeof(IProject));
string path = (string)null;
if (documentNode.Type.RuntimeType == typeof(DesignDataExtension))
{
path = DesignDataInstanceBuilder.GetSourceFilePath((DocumentCompositeNode)documentNode);
}
else if (documentNode.Parent == null)
{
path = documentNode.Context.DocumentUrl;
}
if (!string.IsNullOrEmpty(path))
{
IProjectItem projectItem = project.FindItem(DocumentReference.Create(path));
if (projectItem != null && DocumentContextHelper.GetDesignDataMode(projectItem) != DesignDataMode.None)
{
return(projectItem);
}
}
return((IProjectItem)null);
}
private IProject FindXapSourceProject(IProject targetProject, out DocumentReference xapDeploymentDirectory)
{
xapDeploymentDirectory = (DocumentReference)null;
IProject project = (IProject)null;
if (targetProject is SilverlightProject && targetProject.GetCapability <bool>("CanBeStartupProject"))
{
project = targetProject;
if (project.FullTargetPath != null)
{
xapDeploymentDirectory = DocumentReference.Create(PathHelper.GetDirectoryNameOrRoot(project.FullTargetPath));
}
}
else
{
ISolution currentSolution = ServiceExtensions.ProjectManager(this.serviceProvider).CurrentSolution;
IProjectOutputReferenceResolver referenceResolver = currentSolution as IProjectOutputReferenceResolver;
if (currentSolution != null && referenceResolver != null)
{
foreach (IProject sourceProject in currentSolution.Projects)
{
Uri deploymentResolvedRoot = referenceResolver.GetDeploymentResolvedRoot(sourceProject);
if (deploymentResolvedRoot != (Uri)null)
{
DocumentReference documentReference = DocumentReference.Create(deploymentResolvedRoot.LocalPath);
if (documentReference.Path.StartsWith(targetProject.ProjectRoot.Path, StringComparison.OrdinalIgnoreCase))
{
xapDeploymentDirectory = documentReference;
project = sourceProject;
break;
}
}
}
}
}
return(project);
}
internal static void UpdateImageReferences(DocumentNode parentNode, IDictionary <DocumentNode, string> imageMap, PastePackage pastePackage, SceneViewModel viewModel)
{
foreach (DocumentNode key1 in parentNode.DescendantNodes)
{
if (imageMap.ContainsKey(key1))
{
string index = imageMap[key1];
KeyValuePair <Uri, string> keyValuePair = pastePackage.ImageReferences[index];
Uri key2 = keyValuePair.Key;
DocumentReference documentReference = DocumentReference.Create(keyValuePair.Value);
if (!ResourceHelper.IsResourceInSameProject(viewModel, documentReference, key2))
{
IProjectItem itemForImage = ResourceHelper.CreateItemForImage(viewModel, documentReference, pastePackage);
if (itemForImage != null)
{
documentReference = itemForImage.DocumentReference;
}
}
IDocumentContext referencingDocument = ResourceHelper.DocumentContextFromViewModel(viewModel);
string str = (ResourceHelper.MakeResourceReference(referencingDocument, documentReference) ?? key2).OriginalString;
if (viewModel.Document.ProjectContext.IsCapabilitySet(PlatformCapability.ShouldSanitizeResourceReferences))
{
str = str.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
}
DocumentNode documentNode = (DocumentNode)referencingDocument.CreateNode((ITypeId)key1.Type, (IDocumentNodeValue) new DocumentNodeStringValue(str));
if (key1.IsProperty)
{
key1.Parent.Properties[(IPropertyId)key1.SitePropertyKey] = documentNode;
}
else
{
key1.Parent.Children[key1.SiteChildIndex] = documentNode;
}
}
}
}
private void UpdateLastCut(DataObject thisCut)
{
if (this.lastCut != null && thisCut != this.lastCut && this.lastCut.GetDataPresent(typeof(CutBuffer.ProjectCopyInformation)))
{
CutBuffer.ProjectCopyInformation data = (CutBuffer.ProjectCopyInformation) this.lastCut.GetData(typeof(CutBuffer.ProjectCopyInformation));
if (data.IsCut)
{
IProject project = this.Services.ProjectManager().CurrentSolution.Projects.FindMatchByUrl <IProject>(data.ProjectUrl);
if (project != null)
{
foreach (CutBuffer.ItemCopyInformation item in data.Items)
{
IProjectItem projectItem = project.FindItem(DocumentReference.Create(item.ItemUrl));
if (projectItem == null)
{
continue;
}
projectItem.IsCut = false;
}
}
}
}
this.lastCut = thisCut;
}
private string GetRelativePath(string path)
{
if (string.IsNullOrEmpty(path))
{
return(path);
}
string path1 = path;
try
{
if (!Microsoft.Expression.Framework.Documents.PathHelper.IsPathRelative(path))
{
path1 = DocumentReference.Create(Microsoft.Expression.Framework.Documents.PathHelper.GetDirectory(this.projectContext.ProjectPath)).GetRelativePath(DocumentReference.Create(path));
path1 = Microsoft.Expression.Framework.Documents.PathHelper.TrimTrailingDirectorySeparators(path1);
}
}
catch (ArgumentException ex)
{
}
catch (UriFormatException ex)
{
}
return(path1);
}
protected override sealed void Work()
{
IProjectDocument projectDocument = this.ProjectDocuments[this.currentViewIndex];
if (projectDocument == null)
{
return;
}
bool flag = false;
if (projectDocument.Document == null)
{
IXamlProject xamlProject = this.designerContext.ProjectManager.CurrentSolution.FindProjectContainingItem(DocumentReference.Create(projectDocument.Path)) as IXamlProject;
if (xamlProject == null)
{
return;
}
try
{
projectDocument = xamlProject.ProjectContext.OpenDocument(projectDocument.Path);
}
catch (NotSupportedException ex)
{
return;
}
flag = true;
if (projectDocument == null)
{
return;
}
}
SceneDocument document = projectDocument.Document as SceneDocument;
if (document == null || !document.IsEditable)
{
return;
}
this.ProcessDocument(document);
if (!flag)
{
return;
}
this.CloseDocument(document);
}
public override void Execute()
{
this.HandleBasicExceptions(() => {
string str = this.SelectProject();
if (!string.IsNullOrEmpty(str))
{
this.ProjectManager().AddProject(FileSystemProjectStore.CreateInstance(DocumentReference.Create(str), base.Services));
base.ActivateProjectPane();
}
});
}
