private static IProjectItem CreateItemForImage(SceneViewModel viewModel, DocumentReference localPath, PastePackage pastePackage)
{
try
{
IProject project = ResourceHelper.ProjectFromViewModel(viewModel);
string directoryName = Path.GetDirectoryName(ResourceHelper.DocumentContextFromViewModel(viewModel).DocumentUrl.TrimEnd(Path.DirectorySeparatorChar));
string availableFilePath = ProjectPathHelper.GetAvailableFilePath(Path.GetFileName(localPath.Path), directoryName, project, true);
using (Stream stream = pastePackage.ImageStreams[localPath.Path].GetStream())
{
using (FileStream fileStream = File.Create(availableFilePath, (int)stream.Length, FileOptions.RandomAccess))
Microsoft.Expression.Framework.Clipboard.Container.CopyStream(stream, (Stream)fileStream);
}
IDocumentType documentType = project.GetDocumentType(localPath.Path);
IProjectItem projectItem = project.AddItem(new DocumentCreationInfo()
{
DocumentType = documentType,
TargetPath = availableFilePath,
TargetFolder = directoryName
});
if (projectItem != null)
{
viewModel.DesignerContext.ProjectManager.ItemSelectionSet.SetSelection((IDocumentItem)projectItem);
}
return(projectItem);
}
catch (Exception ex)
{
viewModel.DesignerContext.MessageDisplayService.ShowError(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.PasteElementsParseFailedDialogMessage, new object[1]
{
(object)ex.Message
}));
}
return((IProjectItem)null);
}
internal void BrowseButton_Click(object sender, RoutedEventArgs args)
{
string folderPath = ProjectPathHelper.GetFolderPath(this.browseDialogTitle, this.browseDialogTitleVista, this.NewPath);
if (!string.IsNullOrEmpty(folderPath))
{
this.NewPath = folderPath;
}
}
public void AddProject(string path)
{
var projectPath = ProjectPathHelper.NormalizeProjectDirectoryPath(path);
if (projectPath != null)
{
_needRefresh = _projects.Add(path);
}
}
private void BrowseButton_Click(object sender, RoutedEventArgs args)
{
string folderPath = ProjectPathHelper.GetFolderPath(StringTable.SelectProjectFolderDialogDescription, StringTable.SelectProjectFolderDialogDescriptionVista, this.ProjectPath);
if (!string.IsNullOrEmpty(folderPath))
{
this.ProjectPath = folderPath;
}
}
private void BrowseButton_Click(object sender, RoutedEventArgs args)
{
string folderPath = ProjectPathHelper.GetFolderPath("Select the location for your new project folder.", "Browse For Folder", this.ProjectPath);
if (!string.IsNullOrEmpty(folderPath))
{
this.ProjectPath = folderPath;
}
}
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 GetProjectJsonPath(string projectJson)
{
projectJson = ProjectPathHelper.NormalizeProjectFilePath(projectJson);
if (File.Exists(projectJson))
{
return(projectJson);
}
throw new GracefulException(string.Format(LocalizableStrings.MigratonUnableToFindProjectJson, projectJson));
}
private string GetProjectJsonPath(string projectJson)
{
projectJson = ProjectPathHelper.NormalizeProjectFilePath(projectJson);
if (File.Exists(projectJson))
{
return(projectJson);
}
throw new Exception($"Unable to find project file at {projectJson}");
}
public static int Compare(string first, string second, CultureInfo cultureInfo)
{
AlphabeticThenNumericComparer.SeparatedString separatedString = AlphabeticThenNumericComparer.TrimDigits(first, cultureInfo);
AlphabeticThenNumericComparer.SeparatedString separatedString1 = AlphabeticThenNumericComparer.TrimDigits(second, cultureInfo);
int num = ProjectPathHelper.CompareForDisplay(separatedString.BaseString, separatedString1.BaseString, cultureInfo);
if (num == 0)
{
num = (separatedString.BaseString == first || separatedString1.BaseString == second ? first.CompareTo(second) : separatedString.Number - separatedString1.Number);
}
return(num);
}
public static object CleanPartialCompileDirectory()
{
try
{
string str = Microsoft.Expression.Framework.Documents.PathHelper.ResolveCombinedPath(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), PartialXamlBuilder.DefaultXamlCopyDirectory);
ProjectPathHelper.CleanDirectory(str, true);
}
catch (IOException oException)
{
}
return(null);
}
public static void CleanFontCache()
{
if (FontResolver.createdAnyFontResolvers)
{
return;
}
try
{
ProjectPathHelper.CleanDirectory(FontResolver.fontCacheLocation, true);
}
catch
{
}
}
private void PathTextBox_LostFocus(object sender, RoutedEventArgs e)
{
if (PathHelper.IsValidPath(this.projectPath))
{
if (PathHelper.IsPathRelative(this.projectPath))
{
this.ProjectPath = PathHelper.ResolveRelativePath(this.defaultProjectPath, this.projectPath);
}
if (ProjectPathHelper.IsValidProjectFileName(this.ProjectName))
{
string projectName = this.ProjectName;
string str = null;
string projectPath = this.ProjectPath;
this.ProjectName = PathHelper.GetAvailableFileOrDirectoryName(projectName, str, projectPath, false);
}
}
}
protected sealed override bool InternalConvert(ConversionTarget file, ConversionType initialState, ConversionType targetState)
{
if (this.GetVersion(file) == targetState)
{
return(true);
}
if (!ProjectPathHelper.AttemptToMakeWritable(file.ProjectStore.DocumentReference, base.Context))
{
return(false);
}
if (!this.UpgradeProject(file.ProjectStore, initialState, targetState))
{
return(false);
}
file.ProjectStore.Save();
return(true);
}
public override int CompareTo(HierarchicalNode treeItem)
{
ProjectItemNode projectItemNode = treeItem as ProjectItemNode;
if (projectItemNode == null)
{
return(-1);
}
if (this.ProjectItem is FolderStandIn)
{
return(-1);
}
if (projectItemNode.ProjectItem is FolderStandIn)
{
return(1);
}
IDocumentType item = base.Services.DocumentTypeManager().DocumentTypes[DocumentTypeNamesHelper.Folder];
if (this.ProjectItem.DocumentType == item)
{
if (projectItemNode.ProjectItem.DocumentType != item)
{
return(-1);
}
return(AlphabeticThenNumericComparer.Compare(this.DisplayName, projectItemNode.DisplayName, CultureInfo.CurrentCulture));
}
if (projectItemNode.ProjectItem.DocumentType == item)
{
return(1);
}
try
{
if (Microsoft.Expression.Framework.Documents.PathHelper.GetSafeExtension(this.FullPath) == Microsoft.Expression.Framework.Documents.PathHelper.GetSafeExtension(projectItemNode.FullPath))
{
int num = AlphabeticThenNumericComparer.Compare(Path.GetFileNameWithoutExtension(this.FullPath), Path.GetFileNameWithoutExtension(projectItemNode.FullPath), CultureInfo.CurrentCulture);
return(num);
}
}
catch (ArgumentException argumentException)
{
}
return(ProjectPathHelper.CompareForDisplay(this.DisplayName, projectItemNode.DisplayName, CultureInfo.CurrentCulture));
}
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 bool AttemptToCopyToOutOfBrowserPrivateLocation(DocumentReference xapLocation, DocumentReference privateDeploymentDirectory)
{
if (!PathHelper.FileOrDirectoryExists(xapLocation.Path))
{
return(false);
}
string str = PathHelper.ResolveCombinedPath(privateDeploymentDirectory.Path, OutOfBrowserDeploymentService.PrivateXapName);
IEnumerable <MoveResult> source = (IEnumerable <MoveResult>)ProjectPathHelper.CopySafe((IEnumerable <MoveInfo>) new List <MoveInfo>()
{
new MoveInfo()
{
Source = xapLocation.Path,
Destination = str
}
}, MoveOptions.OverwriteDestination, false);
if (source != null)
{
return(EnumerableExtensions.CountIs <MoveResult>(source, 1));
}
return(false);
}
protected override bool CreateProjectItem()
{
IProjectItem projectItem;
IProject project = this.SelectedProjectOrNull();
if (project == null)
{
return(false);
}
IDocumentType item = base.Services.DocumentTypes()[DocumentTypeNamesHelper.Folder];
string str = this.ProjectManager().TargetFolderForProject(project);
string availableFilePath = ProjectPathHelper.GetAvailableFilePath(item.DefaultFileName, str, project);
Directory.CreateDirectory(availableFilePath);
try
{
List <DocumentCreationInfo> documentCreationInfos = new List <DocumentCreationInfo>();
DocumentCreationInfo documentCreationInfo = new DocumentCreationInfo()
{
DocumentType = item,
TargetPath = availableFilePath
};
documentCreationInfos.Add(documentCreationInfo);
projectItem = project.AddItems(documentCreationInfos).FirstOrDefault <IProjectItem>();
}
catch
{
Directory.Delete(availableFilePath);
throw;
}
if (projectItem != null)
{
base.Services.SetSelection(projectItem);
base.Services.CommandService().Execute("Project_RenameProjectItem", CommandInvocationSource.Internally);
}
return(projectItem != null);
}
public static ProjectContextCollection EnsureValid(this ProjectContextCollection contextCollection, string projectFilePath)
{
IEnumerable <DiagnosticMessage> errors;
if (contextCollection == null)
{
errors = new[]
{
new DiagnosticMessage(
ErrorCodes.DOTNET1017,
$"Project file does not exist '{ProjectPathHelper.NormalizeProjectFilePath(projectFilePath)}'.",
projectFilePath,
DiagnosticMessageSeverity.Error)
};
}
else
{
errors = contextCollection
.ProjectDiagnostics
.Where(d => d.Severity == DiagnosticMessageSeverity.Error);
}
if (errors.Any())
{
StringBuilder errorMessage = new StringBuilder($"The current project is not valid because of the following errors:{Environment.NewLine}");
foreach (DiagnosticMessage message in errors)
{
errorMessage.AppendLine(message.FormattedMessage);
}
throw new GracefulException(errorMessage.ToString());
}
return(contextCollection);
}
public string AddSupportingFileToProject(string fileName, out string sourceReference, bool useExistingFile)
{
sourceReference = (string)null;
IProject activeProject = this.importContext.ActiveProject;
if (activeProject == null)
{
return((string)null);
}
this.GetSupportingFolderName(true);
string path = Microsoft.Expression.Framework.Documents.PathHelper.BuildValidFileName(fileName);
if (path != null)
{
ITypeResolver typeResolver = (ITypeResolver)(activeProject as IXamlProject).ProjectContext;
if (typeResolver != null && !typeResolver.IsCapabilitySet(PlatformCapability.IsWpf))
{
path = path.Replace("%", "");
}
}
string str1;
if (string.IsNullOrEmpty(path))
{
str1 = Microsoft.Expression.Framework.Documents.PathHelper.GetSafeExtension(fileName);
fileName = StringTable.SupportingFilePlaceholder;
if (str1 != null)
{
fileName += str1;
}
}
else
{
fileName = path;
str1 = Path.GetExtension(path);
}
string fullPath = (string)null;
string str2 = (string)null;
bool flag = false;
string str3 = !useExistingFile ? this.temporaryFolderPlaceholder.Path : this.supportingDirectoryPath;
while (true)
{
if (str2 != null)
{
goto label_20;
}
label_10:
try
{
if (useExistingFile)
{
str2 = Path.Combine(str3, fileName);
}
else
{
str2 = ProjectPathHelper.GetAvailableFilePath(fileName, str3, (IProject)null, true);
fileName = Path.GetFileName(str2);
}
fullPath = Path.Combine(this.supportingDirectoryPath, fileName);
if (fullPath.Length > 256 || str2.Length > 256)
{
fullPath = (string)null;
str2 = (string)null;
throw new PathTooLongException();
}
this.supportingFiles.Add(new KeyValuePair <string, string>(str2, fullPath));
continue;
}
catch (Exception ex)
{
if (flag)
{
fullPath = (string)null;
str2 = (string)null;
break;
}
fileName = string.IsNullOrEmpty(str1) ? StringTable.SupportingFilePlaceholder : StringTable.SupportingFilePlaceholder + str1;
flag = true;
continue;
}
label_20:
if (fullPath == null)
{
goto label_10;
}
else
{
break;
}
}
if (fullPath != null && str2 != null)
{
sourceReference = this.importContext.MakeSourceReference(fullPath);
return(str2);
}
sourceReference = (string)null;
return((string)null);
}
private void TryDeleteFile(string fileName, string projectPath)
{
string str = Microsoft.Expression.Framework.Documents.PathHelper.ResolveRelativePath(Path.GetDirectoryName(projectPath), fileName);
if (Microsoft.Expression.Framework.Documents.PathHelper.FileExists(str) && ProjectPathHelper.AttemptToMakeWritable(DocumentReference.Create(str), base.Context))
{
Microsoft.Expression.Framework.Documents.PathHelper.ClearFileOrDirectoryReadOnlyAttribute(str);
File.Delete(str);
}
}
public bool TryCreateDesignTimeResourceReference()
{
bool?nullable = this.doNotAskAgain;
if ((!nullable.GetValueOrDefault() ? 0 : (nullable.HasValue ? true : false)) != 0)
{
this.solutionSettingsManager.SetProjectProperty((INamedProject)this.rootProject, EditDesignTimeResourceModel.DoNotAskForDesignTimeResourcesAgain, (object)true);
}
else
{
this.solutionSettingsManager.ClearProjectProperty((INamedProject)this.rootProject, EditDesignTimeResourceModel.DoNotAskForDesignTimeResourcesAgain);
}
if (this.Selected != null)
{
try
{
List <IProjectItem> itemsToOpen = new List <IProjectItem>();
if (this.designTimeResources == null)
{
TemplateItemHelper templateItemHelper = new TemplateItemHelper(this.rootProject, (IList <string>)null, (IServiceProvider)this.context.Services);
IProjectItemTemplate templateItem = templateItemHelper.FindTemplateItem("Resource Dictionary");
string availableFilePath = ProjectPathHelper.GetAvailableFilePath(EditDesignTimeResourceModel.TargetName, this.targetPath, this.rootProject, true);
this.designTimeResources = Enumerable.SingleOrDefault <IProjectItem>(templateItemHelper.AddProjectItemsForTemplateItem(templateItem, Path.GetFileName(availableFilePath), this.targetPath, CreationOptions.DoNotSelectCreatedItems | CreationOptions.DesignTimeResource, out itemsToOpen));
}
if (this.designTimeResources == null)
{
return(false);
}
DocumentResourceContainer resourceContainer = new DocumentResourceContainer(this.context.ResourceManager, this.designTimeResources);
try
{
if (resourceContainer.ProjectItem.Document == null)
{
return(false);
}
IProject project = this.Selected.Container.ProjectItem.Project;
if (project != this.rootProject && !Enumerable.Contains <IProject>(this.rootProject.ReferencedProjects, project))
{
IProjectItem projectItem = this.rootProject.AddProjectReference(project);
if (projectItem == null)
{
return(false);
}
projectItem.ContainsDesignTimeResources = true;
}
uint resourceChangeStamp = this.context.ResourceManager.ResourceChangeStamp;
this.context.ResourceManager.LinkToResource((ResourceContainer)resourceContainer, this.Selected.Container.DocumentReference);
this.context.ViewUpdateManager.RefreshViewUpdatesForDesignTimeResources(true);
return(this.context.ResourceManager.ResourceChangeStamp > resourceChangeStamp);
}
finally
{
resourceContainer.Close();
}
}
catch (Exception ex)
{
if (ex is NotSupportedException || ErrorHandling.ShouldHandleExceptions(ex))
{
this.context.Services.GetService <IMessageDisplayService>().ShowError(new ErrorArgs()
{
Exception = ex
});
}
else
{
throw;
}
}
}
return(false);
}
protected bool AttemptToMakeWriteable(DocumentReference documentReference)
{
return(ProjectPathHelper.AttemptToMakeWritable(documentReference, this.Context));
}
