public IVsProjectManager GetProjectManager(IVsProject project)
{
#if VS2017
IVsBrowseObjectContext context = project as IVsBrowseObjectContext;
if (context == null)
{
var dteProject = project.GetDTEProject();
if (dteProject != null)
{
context = dteProject.Object as IVsBrowseObjectContext;
}
}
if (context != null)
{
return(new CPSProjectManagerI(context.UnconfiguredProject));
}
else
{
return(new MSBuildProjectManagerI(project.GetDTEProject()));
}
#else
return(new MSBuildProjectManagerI(project.GetDTEProject()));
#endif
}
public void AddFromFile(IVsProject project, string file)
{
#if VS2017 || VS2019
if (project.IsCppProject() || GetUnconfiguredProject(project) == null)
{
project.GetDTEProject().ProjectItems.AddFromFile(file);
}
else
{
project.UpdateProject((MSProject msproject) =>
{
if (Path.GetExtension(file).Equals(".cs", StringComparison.CurrentCultureIgnoreCase))
{
var path = FileUtil.RelativePath(Path.GetDirectoryName(msproject.FullPath), file);
var items = msproject.GetItemsByEvaluatedInclude(path);
if (items.Count == 0)
{
msproject.AddItem("Compile", path);
}
}
});
}
#else
project.GetDTEProject().ProjectItems.AddFromFile(file);
#endif
}
private bool BuildProject(IVsProject project)
{
ThreadHelper.ThrowIfNotOnUIThread();
try
{
BuildLogger logger = new BuildLogger(OutputPane)
{
Verbosity = LoggerVerbosity
};
BuildingProject = project;
var dteproject = project.GetDTEProject();
var activeConfiguration = dteproject.ConfigurationManager.ActiveConfiguration;
Dictionary <string, string> properties = new Dictionary <string, string>();
string platform = activeConfiguration.PlatformName.Equals("Any CPU") ? "AnyCPU" : activeConfiguration.PlatformName;
string configuration = activeConfiguration.ConfigurationName;
if (!Builder.Build(project, new BuildCallback(project, OutputPane), logger, platform, configuration))
{
BuildingProject = null;
}
return(BuildingProject != null);
}
catch (Exception)
{
BuildingProject = null;
return(false);
}
}
public static void AddCSharpGeneratedFiles(IVsProject project, string file)
{
ThreadHelper.ThrowIfNotOnUIThread();
var projectDir = project.GetProjectBaseDirectory();
var dteproject = project.GetDTEProject();
var fileset = GetCsharpGeneratedFiles(project, dteproject, projectDir, file);
//
// First remove any generated items that are not in the
// current generated items set for this Slice file
//
project.DeleteItems(project.WithProject((MSProject msproject) =>
{
return(msproject.AllEvaluatedItems.Where(
item =>
{
if (item.ItemType.Equals("Compile") && item.HasMetadata("SliceCompileSource"))
{
if (item.GetMetadataValue("SliceCompileSource").Equals(fileset.filename))
{
return !fileset.sources.ContainsKey(Path.GetFullPath(Path.Combine(projectDir, item.EvaluatedInclude)));
}
}
return false;
}).Select(item => Path.Combine(projectDir, item.EvaluatedInclude)).ToList());
}));
foreach (var entry in fileset.sources)
{
AddCSharpGeneratedItem(project, dteproject,
projectDir,
FileUtil.RelativePath(projectDir, fileset.filename),
FileUtil.RelativePath(projectDir, entry.Key));
}
}
CheckGenerateFileIsValid(IVsProject project, string path)
{
ThreadHelper.ThrowIfNotOnUIThread();
var projectDir = project.GetProjectBaseDirectory();
var dteproject = project.GetDTEProject();
if (project.IsCSharpProject())
{
var fileset = GetCsharpGeneratedFiles(project, dteproject, projectDir, path);
foreach (var source in fileset.sources.Keys)
{
if (File.Exists(source))
{
const string message =
"A file named '{0}' already exists. If you want to add '{1}' first remove '{0}'.";
UIUtil.ShowErrorDialog("Ice Builder",
string.Format(message,
FileUtil.RelativePath(projectDir, source),
FileUtil.RelativePath(projectDir, path)));
return(false);
}
}
}
else
{
var fileset = GetCppGeneratedFiles(project, dteproject, ProjectFactoryHelperInstance.VCUtil, projectDir, path);
foreach (var source in fileset.sources.Keys)
{
if (File.Exists(source))
{
const string message =
"A file named '{0}' already exists. If you want to add '{1}' first remove '{0}' .";
UIUtil.ShowErrorDialog("Ice Builder",
string.Format(message,
FileUtil.RelativePath(projectDir, source),
FileUtil.RelativePath(projectDir, path)));
return(false);
}
}
foreach (var header in fileset.headers.Keys)
{
if (File.Exists(header))
{
const string message =
"A file named '{0}' already exists. If you want to add '{1}' first remove '{0}' .";
UIUtil.ShowErrorDialog("Ice Builder",
string.Format(message,
FileUtil.RelativePath(projectDir, header),
FileUtil.RelativePath(projectDir, path)));
return(false);
}
}
}
return(true);
}
public static void SetupGenerated(IVsProject project, IceBuilderProjectType type)
{
if (type == IceBuilderProjectType.CppProjectType)
{
//
// This will ensure that property reads don't use a cached project.
//
project.GetMSBuildProject(false);
var generated = GetCppGeneratedFiles(project);
Package.Instance.FileTracker.Reap(GetProjectFullPath(project), GetGeneratedFiles(generated));
Package.Instance.VCUtil.AddGeneratedFiles(project, generated);
}
else // C# project
{
var generated = GetCsharpGeneratedFiles(project);
var dteproject = project.GetDTEProject();
var activeConfiguration = dteproject.ConfigurationManager.ActiveConfiguration;
Package.Instance.FileTracker.Reap(GetProjectFullPath(project), GetGeneratedFiles(generated));
string configName = string.Format("{0}|{1}", activeConfiguration.ConfigurationName, activeConfiguration.PlatformName);
foreach (var fileset in generated)
{
if (fileset.sources.Count > 1)
{
const string message =
"The OutputDir SliceCompile item metadata must evaluate to the same value with all project configurations.";
UIUtil.ShowErrorDialog("Ice Builder", message);
break;
}
var file = fileset.sources.First().Key;
if (!Directory.Exists(Path.GetDirectoryName(file)))
{
Directory.CreateDirectory(Path.GetDirectoryName(file));
}
EnvDTE.ProjectItem item = FindProjectItem(file);
if (item == null)
{
if (!File.Exists(file))
{
File.Create(file).Dispose();
}
dteproject.ProjectItems.AddFromFile(file);
try
{
//
// Remove the file otherwise it will be considered up to date.
//
File.Delete(file);
}
catch (Exception)
{
}
}
}
}
}
public void UpdateProject(IVsProject project, Action <MSProject> action)
{
project.EnsureIsCheckout();
var msproject = project.GetMSBuildProject();
msproject.ReevaluateIfNecessary();
action(msproject);
project.GetDTEProject().Save();
}
CheckGenerateFileIsValid(IVsProject project, IceBuilderProjectType projectType, string path)
{
var projectDir = project.GetProjectBaseDirectory();
var msproject = project.GetMSBuildProject();
if (projectType == IceBuilderProjectType.CsharpProjectType)
{
string outputDir = GetDefaultOutputDir(msproject, true);
string generatedSource = Path.Combine(projectDir, outputDir, GetCSharpGeneratedItemPath(Path.GetFileName(path)));
if (File.Exists(generatedSource))
{
const string message =
"A file named '{0}' already exists.\nIf you want to add '{1}' first remove '{0}'.";
UIUtil.ShowErrorDialog("Ice Builder",
string.Format(message,
GetPathRelativeToProject(project, generatedSource),
GetPathRelativeToProject(project, path)));
return(false);
}
}
else if (projectType == IceBuilderProjectType.CppProjectType)
{
var dteproject = project.GetDTEProject();
var outputDir = GetDefaultOutputDir(msproject, false);
var headerOutputDir = GetDefaultHeaderOutputDir(msproject, false);
var source = GetCppGeneratedSourceItemPath(msproject, path);
var header = GetCppGeneratedHeaderItemPath(msproject, path);
foreach (EnvDTE.Configuration config in dteproject.ConfigurationManager)
{
var evaluatedOutputDir = Package.Instance.VCUtil.Evaluate(config, outputDir);
var evaluatedHeaderOutputDir = headerOutputDir.Equals(outputDir) ? evaluatedOutputDir :
Package.Instance.VCUtil.Evaluate(config, headerOutputDir);
string generatedSource = Path.GetFullPath(Path.Combine(projectDir, evaluatedOutputDir, source));
string generatedHeader = Path.GetFullPath(Path.Combine(projectDir, evaluatedHeaderOutputDir, header));
if (File.Exists(generatedSource) || File.Exists(generatedHeader))
{
const string message =
"A file named '{0}' or '{1}' already exists. If you want to add '{2}' first remove '{0}' and '{1}'.";
UIUtil.ShowErrorDialog("Ice Builder",
string.Format(message,
GetPathRelativeToProject(project, generatedSource),
GetPathRelativeToProject(project, generatedHeader),
GetPathRelativeToProject(project, path)));
return(false);
}
}
}
return(true);
}
public void AddGenerated(IVsProject project, string path, string filter, string platform, string configuration)
{
var dteproject = project.GetDTEProject();
var vcproject = dteproject.Object as VCProject;
var parent = FindOrCreateFilter(vcproject, filter);
parent = FindOrCreateFilter(parent, platform);
parent = FindOrCreateFilter(parent, configuration);
var file = FindFile(vcproject, path);
if (file != null)
{
file.Move(parent);
}
}
public static IceBuilderProjectType IsIceBuilderNuGetInstalled(IVsProject project)
{
if (project != null)
{
IceBuilderProjectType type = IsCppProject(project) ? IceBuilderProjectType.CppProjectType :
IsCSharpProject(project) ? IceBuilderProjectType.CsharpProjectType : IceBuilderProjectType.None;
if (type != IceBuilderProjectType.None)
{
if (Package.Instance.NuGet.IsPackageInstalled(project.GetDTEProject(), Package.NuGetBuilderPackageId) ||
MSBuildUtils.HasIceBuilderPackageReference(project.GetMSBuildProject(true)))
{
return(type);
}
}
}
return(IceBuilderProjectType.None);
}
public void InitializeProject(IVsProject project)
{
if (project.IsMSBuildIceBuilderInstalled())
{
if (project.IsCppProject())
{
VCUtil.SetupSliceFilter(project.GetDTEProject());
}
else
{
if (project is IVsAggregatableProject)
{
project.AddProjectFlavorIfNotExists(IceBuilderNewFlavor);
}
}
}
}
public void UpdateProject(IVsProject project, Action <MSProject> action)
{
project.EnsureIsCheckout();
ThreadHelper.JoinableTaskFactory.Run(async() =>
{
var unconfiguredProject = GetUnconfiguredProject(project);
if (unconfiguredProject != null)
{
await UpdateProjectAsync(unconfiguredProject, action);
}
else
{
var msproject = project.GetMSBuildProject();
msproject.ReevaluateIfNecessary();
action(msproject);
}
});
project.GetDTEProject().Save();
}
GetCsharpGeneratedFiles(IVsProject project)
{
var generated = new List <GeneratedFileSet>();
var msproject = project.GetMSBuildProject();
var dteproject = project.GetDTEProject();
var items = GetIceBuilderItems(project);
var propertyStorage = project as IVsBuildPropertyStorage;
var projectDir = GetProjectBaseDirectory(project);
foreach (var item in items)
{
var fileset = new GeneratedFileSet
{
filename = item,
sources = new Dictionary <string, List <EnvDTE.Configuration> >(),
headers = new Dictionary <string, List <EnvDTE.Configuration> >()
};
var outputDir = msproject.GetItemMetadata(item, "OutputDir");
foreach (EnvDTE.Configuration configuration in dteproject.ConfigurationManager)
{
var configName = string.Format("{0}|{1}", configuration.ConfigurationName, configuration.PlatformName);
var evaluatedOutputDir = Evaluate(propertyStorage, configName, outputDir);
var csFilename = string.Format("{0}.cs", Path.GetFileNameWithoutExtension(item));
csFilename = Path.GetFullPath(Path.Combine(projectDir, evaluatedOutputDir, csFilename));
if (fileset.sources.ContainsKey(csFilename))
{
fileset.sources[csFilename].Add(configuration);
}
else
{
var configurations = new List <EnvDTE.Configuration>();
configurations.Add(configuration);
fileset.sources[csFilename] = configurations;
}
}
generated.Add(fileset);
}
return(generated);
}
public static UnconfiguredProject GetUnconfiguredProject(IVsProject project)
{
UnconfiguredProject unconfiguredProject = null;
ThreadHelper.JoinableTaskFactory.Run(async() =>
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
IVsBrowseObjectContext context = project as IVsBrowseObjectContext;
if (context == null)
{
var dteproject = project.GetDTEProject();
if (dteproject != null)
{
context = dteproject.Object as IVsBrowseObjectContext;
}
}
unconfiguredProject = context != null ? context.UnconfiguredProject : null;
});
return(unconfiguredProject);
}
public void AddGeneratedFiles(IVsProject project, List <GeneratedFileSet> filesets)
{
var dteproject = project.GetDTEProject();
var vcproject = dteproject.Object as VCProject;
var sourcesFilter = FindOrCreateFilter(vcproject, "Source Files");
var headersFilter = FindOrCreateFilter(vcproject, "Header Files");
foreach (var fileset in filesets)
{
foreach (var entry in fileset.sources)
{
AddGeneratedFile(project, sourcesFilter, entry.Key, entry.Value.Count == 1 ? entry.Value.First() : null);
}
foreach (var entry in fileset.headers)
{
AddGeneratedFile(project, headersFilter, entry.Key, entry.Value.Count == 1 ? entry.Value.First() : null);
}
}
}
private bool BuildProject(IVsProject project)
{
try
{
BuildLogger logger = new BuildLogger(OutputPane)
{
Verbosity = LoggerVerbosity
};
BuildingProject = project;
var dteproject = project.GetDTEProject();
var activeConfiguration = dteproject.ConfigurationManager.ActiveConfiguration;
if (!Builder.Build(project, new BuildCallback(project, OutputPane, activeConfiguration), logger))
{
BuildingProject = null;
}
return(BuildingProject != null);
}
catch (Exception)
{
BuildingProject = null;
return(false);
}
}
public void InitializeProject(IVsProject project)
{
IceBuilderProjectType projectType = DTEUtil.IsIceBuilderNuGetInstalled(project);
if (projectType != IceBuilderProjectType.None)
{
var dteproject = project.GetDTEProject();
if (projectType == IceBuilderProjectType.CppProjectType)
{
VCUtil.SetupSliceFilter(dteproject);
}
else
{
if (project is IVsAggregatableProject)
{
if (MSBuildUtils.AddProjectFlavorIfNotExists(project.GetMSBuildProject(true), IceBuilderNewFlavor))
{
dteproject.Save();
}
}
}
FileTracker.Add(project, projectType);
}
}
GetCppGeneratedFiles(IVsProject project)
{
var generated = new List <GeneratedFileSet>();
var msproject = project.GetMSBuildProject();
var dteproject = project.GetDTEProject();
var items = GetIceBuilderItems(project);
var propertyStorage = project as IVsBuildPropertyStorage;
var projectDir = GetProjectBaseDirectory(project);
var vcutil = Package.Instance.VCUtil;
foreach (var item in items)
{
var fileset = new GeneratedFileSet
{
filename = item,
sources = new Dictionary <string, List <EnvDTE.Configuration> >(),
headers = new Dictionary <string, List <EnvDTE.Configuration> >()
};
var outputDir = msproject.GetItemMetadata(item, "OutputDir");
var headerOutputDir = msproject.GetItemMetadata(item, "HeaderOutputDir");
var headerExt = msproject.GetItemMetadata(item, "HeaderExt");
var sourceExt = msproject.GetItemMetadata(item, "SourceExt");
foreach (EnvDTE.Configuration configuration in dteproject.ConfigurationManager)
{
var evaluatedOutputDir = vcutil.Evaluate(configuration, outputDir);
var evaluatedHeaderOutputDir = string.IsNullOrEmpty(headerOutputDir) ?
evaluatedOutputDir : vcutil.Evaluate(configuration, headerOutputDir);
var cppFilename = string.Format("{0}.{1}", Path.GetFileNameWithoutExtension(item), sourceExt);
var hFilename = string.Format("{0}.{1}", Path.GetFileNameWithoutExtension(item), headerExt);
cppFilename = Path.GetFullPath(Path.Combine(projectDir, evaluatedOutputDir, cppFilename));
hFilename = Path.GetFullPath(Path.Combine(projectDir, evaluatedHeaderOutputDir, hFilename));
if (fileset.sources.ContainsKey(cppFilename))
{
fileset.sources[cppFilename].Add(configuration);
}
else
{
var configurations = new List <EnvDTE.Configuration>();
configurations.Add(configuration);
fileset.sources[cppFilename] = configurations;
}
if (fileset.headers.ContainsKey(hFilename))
{
fileset.headers[hFilename].Add(configuration);
}
else
{
var configurations = new List <EnvDTE.Configuration>();
configurations.Add(configuration);
fileset.headers[hFilename] = configurations;
}
}
generated.Add(fileset);
}
return(generated);
}
public static void AddCppGeneratedFiles(IVsProject project, string file)
{
ThreadHelper.ThrowIfNotOnUIThread();
var vcutil = Package.Instance.VCUtil;
var projectDir = project.GetProjectBaseDirectory();
var dteproject = project.GetDTEProject();
var fileset = GetCppGeneratedFiles(project, dteproject, vcutil, projectDir, file);
var allConfigurations = new List <string>();
foreach (EnvDTE.Configuration configuration in dteproject.ConfigurationManager)
{
allConfigurations.Add(ConfigurationString(configuration));
}
//
// First remove any generated items that are not in the
// current generated items set for this Slice file
//
project.DeleteItems(project.WithProject((MSProject msproject) =>
{
return(msproject.AllEvaluatedItems.Where(
item =>
{
if (item.ItemType.Equals("ClCompile") && item.HasMetadata("SliceCompileSource"))
{
if (item.GetMetadataValue("SliceCompileSource").Equals(fileset.filename))
{
return !fileset.sources.ContainsKey(Path.GetFullPath(Path.Combine(projectDir, item.EvaluatedInclude)));
}
}
else if (item.ItemType.Equals("ClInclude") && item.HasMetadata("SliceCompileSource"))
{
if (item.GetMetadataValue("SliceCompileSource").Equals(fileset.filename))
{
return !fileset.headers.ContainsKey(Path.GetFullPath(Path.Combine(projectDir, item.EvaluatedInclude)));
}
}
return false;
}).Select(item => Path.Combine(projectDir, item.EvaluatedInclude)).ToList());
}));
foreach (var entry in fileset.sources)
{
AddCppGeneratedItem(project, dteproject, vcutil,
projectDir,
FileUtil.RelativePath(projectDir, fileset.filename),
FileUtil.RelativePath(projectDir, entry.Key),
"Source Files",
allConfigurations,
entry.Value);
}
foreach (var entry in fileset.headers)
{
AddCppGeneratedItem(project, dteproject, vcutil,
projectDir,
FileUtil.RelativePath(projectDir, fileset.filename),
FileUtil.RelativePath(projectDir, entry.Key), "Header Files", allConfigurations, entry.Value);
}
}
public static void EnsureIsCheckout(this IVsProject project)
{
EnsureIsCheckout(project.GetDTEProject(), project.GetProjectFullPath());
}
private static void EnsureIsCheckout(IVsProject project)
{
EnsureIsCheckout(project.GetDTEProject(), project.GetProjectFullPath());
}
