private IConfigurationObject GetConfigurationForProject(INamedProject project)
{
IConfigurationObject configurationObject;
string relativeReference = this.GetRelativeReference(project);
IEnumerator enumerator = this.projectConfigs.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
IConfigurationObject current = (IConfigurationObject)enumerator.Current;
if (string.CompareOrdinal(relativeReference, current.GetPropertyOrDefault <string>(SolutionSettingsManager.RelativeReference).ToUpperInvariant()) != 0)
{
continue;
}
configurationObject = current;
return(configurationObject);
}
IConfigurationObject configurationObject1 = this.configObject.CreateConfigurationObject();
configurationObject1.SetProperty(SolutionSettingsManager.RelativeReference, relativeReference);
this.projectConfigs.Add(configurationObject1);
return(configurationObject1);
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
return(configurationObject);
}
protected void AddProject(INamedProject project)
{
if (project != null)
{
this.projects.Add(project);
this.OnProjectAdded(new NamedProjectEventArgs(project));
}
}
protected void RemoveProject(INamedProject project)
{
if (project != null && this.projects.Contains(project))
{
this.projects.Remove(project);
this.OnProjectRemoved(new NamedProjectEventArgs(project));
}
}
protected static void MoveProjects(SolutionBase from, SolutionBase to)
{
for (int i = from.projects.Count - 1; i >= 0; i--)
{
INamedProject item = from.projects[i];
from.RemoveProject(item);
to.AddProject(item);
}
}
public void ClearProjectProperty(INamedProject project, string propertyName)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (string.IsNullOrEmpty(propertyName))
{
throw new ArgumentNullException("propertyName");
}
this.GetConfigurationForProject(project).ClearProperty(propertyName);
}
public object GetProjectProperty(INamedProject project, string propertyName)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (string.IsNullOrEmpty(propertyName))
{
throw new ArgumentNullException("propertyName");
}
return(this.GetConfigurationForProject(project).GetPropertyOrDefault <object>(propertyName));
}
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;
}
}
}
});
}
public INamedProject FindProjectByName(string projectName)
{
INamedProject namedProject = null;
foreach (INamedProject project in this.Projects)
{
if (string.CompareOrdinal(project.DocumentReference.DisplayName, projectName) != 0)
{
continue;
}
namedProject = project;
break;
}
return(namedProject);
}
private void OnActivateCommand()
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.ActivateProjectItem);
INamedProject namedProject = base.Services.ProjectManager().CurrentSolution.FindProjectContainingOpenItem(this.projectItem.DocumentReference);
if (namedProject != null && namedProject != this.ProjectItem.Project)
{
base.Services.MessageDisplayService().ShowError(StringTable.ProjectItemAlreadyOpenMessage);
return;
}
IView activeView = base.Services.ViewService().ActiveView;
if (!this.projectItem.DocumentType.CanView)
{
if (this.projectItem is FolderStandIn || this.projectItem.DocumentType == base.Services.DocumentTypes()[DocumentTypeNamesHelper.Folder])
{
this.IsExpanded = !this.IsExpanded;
return;
}
if (activeView != null && this.projectItem.DocumentType.CanInsertTo(this.projectItem, activeView))
{
this.projectItem.DocumentType.AddToDocument(this.projectItem, activeView);
return;
}
if (Microsoft.Expression.Framework.Documents.PathHelper.FileExists(this.projectItem.DocumentReference.Path))
{
CommandTarget commandTarget = base.Services.ProjectManager() as CommandTarget;
if (commandTarget != null)
{
string str = "Project_EditExternally";
commandTarget.SetCommandProperty(str, "TargetDocument", this.ProjectItem);
commandTarget.Execute(str, CommandInvocationSource.Palette);
}
}
}
else
{
using (IDisposable disposable = TemporaryCursor.SetWaitCursor())
{
this.projectItem.OpenView(true);
}
}
}
private void ReloadProject(INamedProject project)
{
IProjectStore projectStore = null;
try
{
this.CloseProject(project);
((ProjectManager)this.Services.ProjectManager()).OnSolutionClosed(new SolutionEventArgs(this));
projectStore = ProjectStoreHelper.CreateProjectStore(project.DocumentReference, this.serviceProvider, ProjectStoreHelper.DefaultProjectCreationChain);
this.OpenProject(projectStore);
((ProjectManager)this.Services.ProjectManager()).OnSolutionOpened(new SolutionEventArgs(this));
}
catch
{
if (projectStore != null)
{
projectStore.Dispose();
}
throw;
}
}
protected override bool LoadInternal()
{
IProjectStore projectStore = ProjectStoreHelper.CreateProjectStore(base.DocumentReference, base.Services, ProjectStoreHelper.ResilientProjectCreationChain);
if (projectStore == null)
{
return(false);
}
if (!(new UpgradeWizard(this, EnumerableExtensions.AsEnumerable <IProjectStore>(projectStore), null, () => {
projectStore.Dispose();
projectStore = ProjectStoreHelper.CreateProjectStore(this.DocumentReference, this.Services, ProjectStoreHelper.DefaultProjectCreationChain);
}, base.Services)).Upgrade())
{
return(false);
}
if (projectStore is MigratingMSBuildStore)
{
projectStore.Dispose();
projectStore = ProjectStoreHelper.CreateProjectStore(base.DocumentReference, base.Services, ProjectStoreHelper.DefaultProjectCreationChain);
}
INamedProject namedProject = null;
try
{
namedProject = base.OpenProject(projectStore);
if (namedProject != null)
{
base.OpenInitialScene();
}
}
finally
{
if (namedProject == null && projectStore != null)
{
projectStore.Dispose();
}
}
return(namedProject != null);
}
private void CloseProject(INamedProject project)
{
IProjectItem projectItem2 = null;
PerformanceUtility.StartPerformanceSequence(PerformanceEvent.ProjectClose);
try
{
IProject project1 = project as IProject;
if (project1 != null)
{
((ProjectManager)this.Services.ProjectManager()).OnProjectClosing(new ProjectEventArgs(project1));
}
ItemSelectionSet itemSelectionSet = this.Services.ProjectManager().ItemSelectionSet;
itemSelectionSet.RemoveSelection((IDocumentItem selection) => {
IProjectItem projectItem = selection as IProjectItem;
IProjectItem projectItem1 = projectItem;
projectItem2 = projectItem;
if (projectItem1 == null)
{
return(false);
}
return(projectItem2.Project == project);
});
itemSelectionSet.RemoveSelection(project);
((ProjectManager)this.Services.ProjectManager()).UpdateCurrentWorkingDirectory(null);
project.Dispose();
}
finally
{
this.RemoveProject(project);
if (this.StartupProject == project)
{
this.StartupProject = null;
}
this.OnAnyProjectClosed(new NamedProjectEventArgs(project));
}
PerformanceUtility.EndPerformanceSequence(PerformanceEvent.ProjectClose);
}
protected INamedProject OpenProject(IProjectStore projectStore)
{
INamedProject namedProject = null;
ErrorHandling.HandleBasicExceptions(() => namedProject = this.InitializeProject(projectStore), (Exception exception) => {
this.Services.MessageDisplayService().ShowError(string.Format(CultureInfo.CurrentCulture, StringTable.DialogFailedMessage, new object[] { string.Format(CultureInfo.CurrentCulture, StringTable.DialogOpenFailedMessage, new object[] { projectStore.DocumentReference.DisplayName }), exception.Message }));
namedProject = null;
});
if (namedProject != null)
{
try
{
this.OpenProjectInternal(namedProject);
}
catch
{
namedProject.Dispose();
namedProject = null;
throw;
}
}
return(namedProject);
}
public IEnumerable <INamedProject> CreateProjects(string name, string path, IEnumerable <TemplateArgument> templateArguments, IServiceProvider serviceProvider)
{
Uri uri;
IEnumerable <INamedProject> namedProjects;
ICodeDocumentType codeDocumentType = base.GetCodeDocumentType(serviceProvider);
if (templateArguments != null)
{
templateArguments = templateArguments.Concat <TemplateArgument>(TemplateManager.GetDefaultArguments(serviceProvider.ExpressionInformationService()));
}
else
{
templateArguments = TemplateManager.GetDefaultArguments(serviceProvider.ExpressionInformationService());
}
TemplateArgument templateArgument = new TemplateArgument("projectname", name);
if (!base.Template.TemplateData.CreateNewFolderSpecified || base.Template.TemplateData.CreateNewFolder)
{
path = Microsoft.Expression.Framework.Documents.PathHelper.ResolveCombinedPath(path, name);
Directory.CreateDirectory(path);
}
List <INamedProject> namedProjects1 = new List <INamedProject>();
Uri uri1 = null;
try
{
uri1 = new Uri(Microsoft.Expression.Framework.Documents.PathHelper.EnsurePathEndsInDirectorySeparator(path));
}
catch (UriFormatException uriFormatException)
{
namedProjects = namedProjects1;
return(namedProjects);
}
List <Uri> uris = new List <Uri>();
List <ProjectTemplate.FileToOpen> fileToOpens = new List <ProjectTemplate.FileToOpen>();
List <ProjectTemplate.SourceDestination> sourceDestinations = new List <ProjectTemplate.SourceDestination>();
string str = CodeGenerator.MakeSafeIdentifier(codeDocumentType, name, false);
string str1 = CodeGenerator.MakeSafeIdentifier(codeDocumentType, name, true);
TemplateArgument templateArgument1 = new TemplateArgument("safeprojectname", str);
TemplateArgument templateArgument2 = new TemplateArgument("safeprojectname", str1);
TemplateArgument templateArgument3 = new TemplateArgument("assemblyname", name);
TemplateArgument templateArgument4 = new TemplateArgument("safeassemblyname", name.Replace(' ', '\u005F'));
using (ProjectPathHelper.TemporaryDirectory temporaryDirectory = new ProjectPathHelper.TemporaryDirectory(true))
{
foreach (VSTemplateTemplateContentProject templateProject in this.TemplateProjects)
{
if (!string.IsNullOrEmpty(templateProject.File))
{
string targetFileName = templateProject.TargetFileName;
if (string.IsNullOrEmpty(targetFileName))
{
targetFileName = string.Concat(name, Path.GetExtension(templateProject.File));
}
TemplateArgument[] templateArgumentArray = new TemplateArgument[] { templateArgument, templateArgument1, templateArgument3, templateArgument4 };
IEnumerable <TemplateArgument> templateArguments1 = templateArguments.Concat <TemplateArgument>(templateArgumentArray);
uri = base.ResolveFileUri(targetFileName, uri1);
string str2 = TemplateParser.ReplaceTemplateArguments(uri.LocalPath, templateArguments1);
uri = new Uri(str2);
if (!string.IsNullOrEmpty(templateProject.File) && !base.IsDirectory(templateProject.File))
{
Uri uri2 = new Uri(temporaryDirectory.GenerateTemporaryFileName());
base.CreateFile(templateProject.File, base.TemplateLocation, uri2, templateProject.ReplaceParameters, templateArguments1);
ProjectTemplate.SourceDestination sourceDestination = new ProjectTemplate.SourceDestination()
{
Source = uri2,
Destination = uri
};
sourceDestinations.Add(sourceDestination);
}
}
else
{
uri = uri1;
}
foreach (Microsoft.Expression.Project.Templates.ProjectItem projectItem in templateProject.Items.OfType <Microsoft.Expression.Project.Templates.ProjectItem>())
{
string value = projectItem.TargetFileName;
if (string.IsNullOrEmpty(value))
{
value = projectItem.Value;
}
int num = projectItem.Value.IndexOf('.');
string str3 = (num != -1 ? projectItem.Value.Remove(num) : projectItem.Value);
bool flag = Path.GetExtension(projectItem.Value).Equals(codeDocumentType.DefaultFileExtension, StringComparison.OrdinalIgnoreCase);
string str4 = CodeGenerator.MakeSafeIdentifier(codeDocumentType, str3, flag);
TemplateArgument[] templateArgumentArray1 = new TemplateArgument[] { templateArgument, templateArgument3, templateArgument4, null, null, null };
templateArgumentArray1[3] = (flag ? templateArgument2 : templateArgument1);
templateArgumentArray1[4] = new TemplateArgument("safeitemname", str4);
templateArgumentArray1[5] = new TemplateArgument("safeitemrootname", str4);
TemplateArgument[] templateArgumentArray2 = templateArgumentArray1;
string str5 = TemplateParser.ReplaceTemplateArguments(value, templateArguments.Concat <TemplateArgument>(templateArgumentArray2));
Uri uri3 = base.ResolveFileUri(str5, uri1);
Uri uri4 = new Uri(temporaryDirectory.GenerateTemporaryFileName());
if (!base.CreateFile(projectItem.Value, base.TemplateLocation, uri4, projectItem.ReplaceParameters, templateArguments.Concat <TemplateArgument>(templateArgumentArray2)))
{
continue;
}
if (projectItem.OpenInEditorSpecified && projectItem.OpenInEditor)
{
ProjectTemplate.FileToOpen fileToOpen = new ProjectTemplate.FileToOpen()
{
ProjectFile = uri,
ProjectItem = uri3
};
fileToOpens.Add(fileToOpen);
}
ProjectTemplate.SourceDestination sourceDestination1 = new ProjectTemplate.SourceDestination()
{
Source = uri4,
Destination = uri3
};
sourceDestinations.Add(sourceDestination1);
}
uris.Add(uri);
}
foreach (ProjectTemplate.SourceDestination sourceDestination2 in sourceDestinations)
{
string localPath = sourceDestination2.Destination.LocalPath;
if (!Microsoft.Expression.Framework.Documents.PathHelper.FileOrDirectoryExists(localPath))
{
continue;
}
IMessageDisplayService messageDisplayService = serviceProvider.MessageDisplayService();
CultureInfo currentUICulture = CultureInfo.CurrentUICulture;
string cannotCreateTemplateDirectoryOrFileExistsMessage = StringTable.CannotCreateTemplateDirectoryOrFileExistsMessage;
object[] objArray = new object[] { localPath };
messageDisplayService.ShowError(string.Format(currentUICulture, cannotCreateTemplateDirectoryOrFileExistsMessage, objArray));
namedProjects = namedProjects1;
return(namedProjects);
}
foreach (ProjectTemplate.SourceDestination sourceDestination3 in sourceDestinations)
{
base.CreateFile(sourceDestination3.Source.LocalPath, new Uri(Path.GetDirectoryName(sourceDestination3.Source.LocalPath)), sourceDestination3.Destination, false, Enumerable.Empty <TemplateArgument>());
}
foreach (Uri uri5 in uris)
{
DocumentReference documentReference = DocumentReference.Create(uri5.LocalPath);
IProjectStore projectStore = null;
INamedProject namedProject = null;
try
{
projectStore = ProjectStoreHelper.CreateProjectStore(documentReference, serviceProvider, ProjectStoreHelper.DefaultProjectCreationChain);
namedProject = serviceProvider.ProjectManager().AddProject(projectStore);
}
finally
{
if (namedProject == null && projectStore != null)
{
projectStore.Dispose();
}
}
if (namedProject == null)
{
continue;
}
namedProjects1.Add(namedProject);
}
foreach (ProjectTemplate.FileToOpen fileToOpen1 in fileToOpens)
{
ISolution currentSolution = serviceProvider.ProjectManager().CurrentSolution;
if (currentSolution == null)
{
continue;
}
IProject project = currentSolution.Projects.FindMatchByUrl <IProject>(fileToOpen1.ProjectFile.LocalPath);
if (project == null)
{
continue;
}
IProjectItem projectItem1 = project.Items.FindMatchByUrl <IProjectItem>(fileToOpen1.ProjectItem.LocalPath);
if (projectItem1 == null)
{
continue;
}
projectItem1.OpenView(true);
}
return(namedProjects1);
}
return(namedProjects);
}
public NamedProjectEventArgs(INamedProject namedProject)
{
this.NamedProject = namedProject;
}
private string GetRelativeReference(INamedProject project)
{
return(this.solution.DocumentReference.GetRelativePath(project.DocumentReference).ToUpperInvariant());
}
protected void OpenProjectInternal(INamedProject project)
{
PerformanceUtility.MarkInterimStep(PerformanceEvent.ProjectManagerOpenProject, "projects.Add");
this.AddProject(project);
this.OnAnyProjectOpened(new NamedProjectEventArgs(project));
}
internal ProjectNode(INamedProject project, Microsoft.Expression.Project.UserInterface.ProjectPane projectPane) : base(project, projectPane)
{
this.project = project;
base.IsExpandedChanged += new EventHandler(this.ProjectItemNode_IsExpandedChanged);
}
void Microsoft.Expression.Project.ISolutionManagement.CloseProject(INamedProject project)
{
this.CloseProject(project);
}
protected INamedProject InitializeProject(IProjectStore projectStore)
{
INamedProject namedProject;
INamedProject unlicensedProject = null;
try
{
IProjectType projectTypeForProject = this.Services.ProjectTypeManager().GetProjectTypeForProject(projectStore);
if (projectTypeForProject != null)
{
IProjectCreateError projectCreateError = projectTypeForProject.CanCreateProject(projectStore);
if (projectCreateError != null)
{
projectTypeForProject = this.Services.ProjectTypeManager().UnknownProjectType;
}
if (projectTypeForProject is UnknownProjectType && SolutionBase.IsReloadPromptEnabled())
{
InvalidProjectStore invalidProjectStore = projectStore as InvalidProjectStore;
if (invalidProjectStore == null || string.IsNullOrEmpty(invalidProjectStore.InvalidStateDescription))
{
this.PromptWithUnsupportedProjectDetails(projectStore, projectCreateError);
}
else
{
IMessageDisplayService messageDisplayService = this.Services.MessageDisplayService();
ErrorArgs errorArg = new ErrorArgs();
CultureInfo currentUICulture = CultureInfo.CurrentUICulture;
string unsupportedProjectWithDescription = StringTable.UnsupportedProjectWithDescription;
object[] displayName = new object[] { projectStore.DocumentReference.DisplayName, invalidProjectStore.InvalidStateDescription };
errorArg.Message = string.Format(currentUICulture, unsupportedProjectWithDescription, displayName);
errorArg.AutomationId = "OpenProjectErrorDialog";
messageDisplayService.ShowError(errorArg);
}
}
LicenseState licenseState = LicensingHelper.IsProjectLicensed(projectStore, this.serviceProvider);
if (!licenseState.IsExpired)
{
if (!licenseState.FullyLicensed)
{
LicensingHelper.UnlicensedProjectLoadAttempted();
}
unlicensedProject = projectTypeForProject.CreateProject(projectStore, this.GetCodeDocumentTypeFromProject(projectStore), this.serviceProvider);
}
else
{
LicensingHelper.UnlicensedProjectLoadAttempted();
unlicensedProject = new UnlicensedProject(projectStore, this.serviceProvider);
}
return(unlicensedProject);
}
else
{
namedProject = null;
}
}
catch (Exception exception)
{
if (unlicensedProject != null)
{
projectStore.Dispose();
unlicensedProject.Dispose();
unlicensedProject = null;
}
throw;
}
return(namedProject);
}
