public int OnAfterRenameFiles(int projectsLength, int filesLength, IVsProject[] projects, int[] indices,
string[] oldNames, string[] newNames, VSRENAMEFILEFLAGS[] rgFlags)
{
try
{
for (int i = 0; i < projectsLength; ++i)
{
IVsProject project = projects[i];
IceBuilderProjectType projectType = DTEUtil.IsIceBuilderNuGetInstalled(project);
if (projectType != IceBuilderProjectType.None)
{
int j = indices[i];
int k = i < (projectsLength - 1) ? indices[i + 1] : filesLength;
for (; j < k; ++j)
{
string oldPath = oldNames[i];
string newPath = newNames[j];
if (ProjectUtil.IsSliceFileName(oldPath) || ProjectUtil.IsSliceFileName(newPath))
{
ProjectUtil.SetupGenerated(project, projectType);
break;
}
}
}
}
}
catch (Exception ex)
{
Package.UnexpectedExceptionWarning(ex);
}
return(0);
}
public int OnQueryAddFiles(IVsProject project, int length, string[] files,
VSQUERYADDFILEFLAGS[] rgFlags, VSQUERYADDFILERESULTS[] pSummaryResult,
VSQUERYADDFILERESULTS[] rgResults)
{
try
{
if (files.Any(f => ProjectUtil.IsSliceFileName(f)))
{
IceBuilderProjectType projectType = DTEUtil.IsIceBuilderNuGetInstalled(project);
if (projectType != IceBuilderProjectType.None)
{
for (int i = 0; i < length; ++i)
{
if (ProjectUtil.IsSliceFileName(files[i]))
{
if (!ProjectUtil.CheckGenerateFileIsValid(project, projectType, files[i]))
{
pSummaryResult[i] = VSQUERYADDFILERESULTS.VSQUERYADDFILERESULTS_AddNotOK;
}
}
}
}
}
}
catch (Exception ex)
{
Package.UnexpectedExceptionWarning(ex);
}
return(0);
}
public int OnAfterRemoveFiles(int projectsLength, int filesLength, IVsProject[] projects, int[] indices,
string[] names, VSREMOVEFILEFLAGS[] rgFlags)
{
try
{
for (int i = 0; i < projectsLength; ++i)
{
IVsProject project = projects[i];
IceBuilderProjectType projectType = DTEUtil.IsIceBuilderEnabled(project);
if (projectType != IceBuilderProjectType.None)
{
int j = indices[i];
int k = i < (projectsLength - 1) ? indices[i + 1] : filesLength;
for (; j < k; ++j)
{
string path = names[i];
if (ProjectUtil.IsSliceFileName(path))
{
ProjectUtil.SetupGenerated(project, projectType);
break;
}
}
}
}
}
catch (Exception ex)
{
Package.UnexpectedExceptionWarning(ex);
throw;
}
return(0);
}
public int OnQueryRenameFiles(IVsProject project, int filesLength, string[] oldNames, string[] newNames,
VSQUERYRENAMEFILEFLAGS[] rgFlags, VSQUERYRENAMEFILERESULTS[] pSummaryResult,
VSQUERYRENAMEFILERESULTS[] rgResults)
{
try
{
IceBuilderProjectType projectType = DTEUtil.IsIceBuilderNuGetInstalled(project);
if (projectType != IceBuilderProjectType.None)
{
for (int i = 0; i < filesLength; ++i)
{
if (ProjectUtil.IsSliceFileName(newNames[i]))
{
if (!ProjectUtil.CheckGenerateFileIsValid(project, projectType, newNames[i]))
{
rgResults[i] = VSQUERYRENAMEFILERESULTS.VSQUERYRENAMEFILERESULTS_RenameNotOK;
}
}
}
}
}
catch (Exception ex)
{
Package.UnexpectedExceptionWarning(ex);
}
return(0);
}
public void InitializeProjects(List <IVsProject> upgradeProjects)
{
ProjectConverter.TryUpgrade(upgradeProjects);
List <IVsProject> projects = DTEUtil.GetProjects();
List <IVsProject> sliceProjects = new List <IVsProject>();
foreach (IVsProject project in projects)
{
IceBuilderProjectType projectType = DTEUtil.IsIceBuilderEnabled(project);
if (projectType != IceBuilderProjectType.None)
{
if (projectType == IceBuilderProjectType.CppProjectType)
{
VCUtil.SetupSliceFilter(DTEUtil.GetProject(project as IVsHierarchy));
}
if (AutoBuilding)
{
sliceProjects.Add(project);
}
else
{
FileTracker.Add(project, projectType);
}
}
}
if (AutoBuilding)
{
QueueProjectsForBuilding(sliceProjects);
}
}
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)
{
}
}
}
}
}
CheckGenerateFileIsValid(IVsProject project, IceBuilderProjectType projectType, string path)
{
if (projectType == IceBuilderProjectType.CsharpProjectType)
{
string outputDir = GetOutputDir(project, false, true);
string generatedSource = 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)
{
string source = GetCppGeneratedSourceItemPath(project, path);
string header = GetCppGeneratedHeaderItemPath(project, path);
EnvDTE.Project p = DTEUtil.GetProject(project as IVsHierarchy);
foreach (EnvDTE.Configuration config in p.ConfigurationManager)
{
string outputDir = Package.Instance.VCUtil.Evaluate(config, "$(IceBuilderOutputDir)");
outputDir = Path.GetFullPath(Path.Combine(GetProjectBaseDirectory(project), outputDir));
string headerOutputDir = Package.Instance.VCUtil.Evaluate(config, "$(IceBuilderHeaderOutputDir)");
if (string.IsNullOrEmpty(headerOutputDir))
{
headerOutputDir = outputDir;
}
else
{
headerOutputDir = Path.GetFullPath(Path.Combine(GetProjectBaseDirectory(project), headerOutputDir));
}
string generatedSource = Path.GetFullPath(Path.Combine(outputDir, source));
string generatedHeader = Path.GetFullPath(Path.Combine(headerOutputDir, header));
if (File.Exists(generatedSource) || File.Exists(generatedHeader))
{
const string message =
"A file named '{0}' or '{1}' already exists.\nIf 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 Add(IVsProject project, IceBuilderProjectType type)
{
String projectFullPath = ProjectUtil.GetProjectFullPath(project);
Remove(projectFullPath);
_generated.Add(projectFullPath,
type == IceBuilderProjectType.CsharpProjectType ?
ProjectUtil.GetCSharpGeneratedFiles(project) :
ProjectUtil.GetCppGeneratedFiles(ProjectUtil.GetCppGeneratedFiles(project)));
}
public static void SetupGenerated(IVsProject project, IceBuilderProjectType type)
{
if (type == IceBuilderProjectType.CppProjectType)
{
//
// This will ensure that property reads don't use a cached project.
//
MSBuildUtils.LoadedProject(ProjectUtil.GetProjectFullPath(project), true, false);
List <CppGeneratedFileSet> generated = GetCppGeneratedFiles(project);
foreach (CppGeneratedFileSet fileset in generated)
{
SetupGenerated(project, fileset.configuration, "Source Files", fileset.sources, generated.Count > 1);
SetupGenerated(project, fileset.configuration, "Header Files", fileset.headers, generated.Count > 1);
}
Package.Instance.FileTracker.Reap(GetProjectFullPath(project), GetCppGeneratedFiles(generated));
}
else // C# project
{
EnvDTE.Project p = DTEUtil.GetProject(project as IVsHierarchy);
Dictionary <String, List <String> > generated = GetCSharpGeneratedFiles(project);
foreach (KeyValuePair <String, List <String> > i in generated)
{
foreach (String file in i.Value)
{
if (!Directory.Exists(Path.GetDirectoryName(file)))
{
Directory.CreateDirectory(Path.GetDirectoryName(file));
}
if (!File.Exists(file))
{
File.Create(file).Dispose();
}
EnvDTE.ProjectItem item = FindProjectItem(file);
if (item == null)
{
p.ProjectItems.AddFromFile(file);
try
{
//
// Remove the file otherwise it will be considered up to date.
//
File.Delete(file);
}
catch (Exception)
{
}
}
}
}
Package.Instance.FileTracker.Reap(GetProjectFullPath(project), generated);
}
}
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 static IceBuilderProjectType IsIceBuilderEnabled(IVsProject project)
{
if (project != null)
{
IceBuilderProjectType type = IsCppProject(project) ? IceBuilderProjectType.CppProjectType :
IsCSharpProject(project) ? IceBuilderProjectType.CsharpProjectType : IceBuilderProjectType.None;
if (type != IceBuilderProjectType.None)
{
if (MSBuildUtils.IsIceBuilderEnabled(project.GetMSBuildProject(true)))
{
return(type);
}
}
}
return(IceBuilderProjectType.None);
}
private void BuildEvents_OnBuildBegin(EnvDTE.vsBuildScope scope, EnvDTE.vsBuildAction action)
{
try
{
if (action == EnvDTE.vsBuildAction.vsBuildActionBuild ||
action == EnvDTE.vsBuildAction.vsBuildActionRebuildAll)
{
//
// Ensure this runs once for parallel builds.
//
if (Building)
{
return;
}
Building = true;
}
List <IVsProject> projects = new List <IVsProject>();
if (scope.Equals(EnvDTE.vsBuildScope.vsBuildScopeSolution))
{
projects = DTEUtil.GetProjects();
}
else
{
IVsProject selected = DTEUtil.GetSelectedProject();
if (selected != null)
{
projects.Add(selected);
DTEUtil.GetSubProjects(selected, ref projects);
}
}
foreach (IVsProject project in projects)
{
IceBuilderProjectType type = DTEUtil.IsIceBuilderEnabled(project);
if (type != IceBuilderProjectType.None)
{
ProjectUtil.SetupGenerated(project, type);
}
}
}
catch (Exception ex)
{
Package.UnexpectedExceptionWarning(ex);
throw;
}
}
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 static IceBuilderProjectType IsIceBuilderEnabled(IVsProject project)
{
if (project != null)
{
IceBuilderProjectType type = IsCppProject(project) ? IceBuilderProjectType.CppProjectType :
IsCSharpProject(project) ? IceBuilderProjectType.CsharpProjectType : IceBuilderProjectType.None;
if (type != IceBuilderProjectType.None)
{
if (MSBuildUtils.IsIceBuilderEnabled(MSBuildUtils.LoadedProject(ProjectUtil.GetProjectFullPath(project),
DTEUtil.IsCppProject(project),
true)))
{
return(type);
}
}
}
return(IceBuilderProjectType.None);
}
//
// Check if IceBuilder 4.x is enabled
//
public static IceBuilderProjectType IsIceBuilderEnabled(IVsProject project)
{
if (project != null)
{
IceBuilderProjectType type = project.IsCppProject() ? IceBuilderProjectType.CppProjectType :
project.IsCSharpProject() ? IceBuilderProjectType.CsharpProjectType : IceBuilderProjectType.None;
if (type != IceBuilderProjectType.None)
{
return(project.WithProject((MSProject msproject) =>
{
if (MSBuildUtils.IsIceBuilderEnabled(msproject))
{
return type;
}
return IceBuilderProjectType.None;
}));
}
}
return(IceBuilderProjectType.None);
}
public static void TryUpgrade(List <IVsProject> projects)
{
Dictionary <string, IVsProject> upgradeProjects = new Dictionary <string, IVsProject>();
foreach (IVsProject project in projects)
{
IceBuilderProjectType projectType = IsIceBuilderEnabled(project);
if (projectType != IceBuilderProjectType.None)
{
upgradeProjects.Add(project.GetDTEProject().UniqueName, project);
}
}
if (upgradeProjects.Count > 0)
{
UpgradeDialog dialog = new UpgradeDialog();
dialog.StartPosition = FormStartPosition.CenterParent;
dialog.Projects = upgradeProjects;
dialog.ShowDialog();
}
}
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);
}
}
public static Dictionary <string, List <string> > GetGeneratedFiles(IVsProject project, IceBuilderProjectType type)
{
return(type == IceBuilderProjectType.CsharpProjectType ?
GetCSharpGeneratedFiles(project) : GetCppGeneratedFiles(GetCppGeneratedFiles(project)));
}
public static void Upgrade(Dictionary <string, IVsProject> projects, UpgradeProgressCallback progressCallback)
{
Dispatcher dispatcher = Dispatcher.CurrentDispatcher;
Thread t = new Thread(() =>
{
try
{
var NuGet = Package.Instance.NuGet;
if (!NuGet.IsUserConsentGranted())
{
Package.WriteMessage("Ice Builder cannot download the required NuGet packages because " +
"\"Allow NuGet to download missing packages\" is disabled");
dispatcher.Invoke(new Action(() => progressCallback.Finished()));
return;
}
var DTE = Package.Instance.DTE;
var builder = Package.Instance;
int i = 0;
int total = projects.Count;
foreach (var entry in projects)
{
var project = entry.Value;
var dteProject = project.GetDTEProject();
var uniqueName = dteProject.UniqueName;
var name = entry.Key;
i++;
if (progressCallback.Canceled)
{
break;
}
dispatcher.Invoke(
new Action(() =>
{
progressCallback.ReportProgress(name, i);
}));
try
{
NuGet.Restore(dteProject);
}
catch (Exception ex)
{
Package.WriteMessage(
string.Format("\nNuGet package restore failed:\n{0}\n", ex.Message));
dispatcher.Invoke(new Action(() => progressCallback.Finished()));
break;
}
if (!NuGet.IsPackageInstalled(dteProject, Package.NuGetBuilderPackageId))
{
try
{
DTE.StatusBar.Text = string.Format("Installing NuGet package {0} in project {1}",
Package.NuGetBuilderPackageId, name);
NuGet.InstallLatestPackage(dteProject, Package.NuGetBuilderPackageId);
}
catch (Exception ex)
{
Package.WriteMessage(
string.Format("\nNuGet package zeroc.icebuilder.msbuild install failed:\n{0}\n", ex.Message));
dispatcher.Invoke(new Action(() => progressCallback.Finished()));
break;
}
}
IceBuilderProjectType projectType = IsIceBuilderEnabled(project);
if (projectType != IceBuilderProjectType.None)
{
bool cpp = projectType == IceBuilderProjectType.CppProjectType;
DTE.StatusBar.Text = string.Format("Upgrading project {0} Ice Builder settings", project.GetDTEProject().UniqueName);
var fullPath = project.GetProjectFullPath();
var assemblyDir = project.GetEvaluatedProperty("IceAssembliesDir");
var outputDir = project.GetEvaluatedProperty("IceBuilderOutputDir");
var outputDirUnevaluated = project.GetPropertyWithDefault("IceBuilderOutputDir", "generated");
var sourceExt = project.GetPropertyWithDefault("IceBuilderSourceExt", "cpp");
var headerOutputDirUnevaluated = project.GetProperty("IceBuilderHeaderOutputDir");
var headerExt = project.GetPropertyWithDefault("IceBuilderHeaderExt", "h");
var cppOutputDir = new List <string>();
var cppHeaderOutputDir = new List <string>();
if (cpp)
{
var waitEvent = new ManualResetEvent(false);
dispatcher.BeginInvoke(new Action(() =>
{
foreach (EnvDTE.Configuration configuration in dteProject.ConfigurationManager)
{
cppOutputDir.Add(Package.Instance.VCUtil.Evaluate(configuration, outputDirUnevaluated));
if (string.IsNullOrEmpty(headerOutputDirUnevaluated))
{
cppHeaderOutputDir.Add(Package.Instance.VCUtil.Evaluate(configuration, outputDirUnevaluated));
}
else
{
cppHeaderOutputDir.Add(Package.Instance.VCUtil.Evaluate(configuration, headerOutputDirUnevaluated));
}
}
waitEvent.Set();
}));
waitEvent.WaitOne();
}
else
{
foreach (VSLangProj80.Reference3 r in dteProject.GetProjectRererences())
{
if (Package.AssemblyNames.Contains(r.Name))
{
project.UpdateProject((MSProject msproject) =>
{
var item = msproject.AllEvaluatedItems.FirstOrDefault(referenceItem =>
referenceItem.ItemType.Equals("Reference") &&
referenceItem.EvaluatedInclude.Split(",".ToCharArray()).ElementAt(0).Equals(r.Name));
if (item != null)
{
if (item.HasMetadata("HintPath"))
{
var hintPath = item.GetMetadata("HintPath").UnevaluatedValue;
if (hintPath.Contains("$(IceAssembliesDir)"))
{
hintPath = hintPath.Replace("$(IceAssembliesDir)",
FileUtil.RelativePath(Path.GetDirectoryName(r.ContainingProject.FullName), assemblyDir));
//
// If the HintPath points to the NuGet zeroc.ice.net package we upgrade it to not
// use IceAssembliesDir otherwise we remove it
if (hintPath.Contains("packages\\zeroc.ice.net"))
{
item.SetMetadataValue("HintPath", hintPath);
}
else
{
item.RemoveMetadata("HintPath");
}
}
}
}
});
}
}
}
project.UpdateProject((MSProject msproject) =>
{
MSBuildUtils.UpgradeProjectImports(msproject);
MSBuildUtils.UpgradeProjectProperties(msproject, cpp);
MSBuildUtils.RemoveIceBuilderFromProject(msproject, true);
MSBuildUtils.UpgradeProjectItems(msproject);
MSBuildUtils.UpgradeCSharpGeneratedItems(msproject, outputDir);
foreach (var d in cppOutputDir)
{
MSBuildUtils.UpgradeGeneratedItems(msproject, d, sourceExt, "ClCompile");
}
foreach (var d in cppHeaderOutputDir)
{
MSBuildUtils.UpgradeGeneratedItems(msproject, d, headerExt, "ClInclude");
}
var propertyGroup = msproject.Xml.PropertyGroups.FirstOrDefault(group => group.Label.Equals("IceBuilder"));
if (propertyGroup != null)
{
propertyGroup.Parent.RemoveChild(propertyGroup);
}
if (cpp)
{
propertyGroup = msproject.Xml.AddPropertyGroup();
propertyGroup.Label = "IceBuilder";
propertyGroup.AddProperty("IceCppMapping", "cpp98");
}
});
builder.ReloadProject(project);
}
}
dispatcher.BeginInvoke(new Action(() => progressCallback.Finished()));
}
catch (Exception ex)
{
dispatcher.BeginInvoke(new Action(() => progressCallback.Canceled = true));
Package.UnexpectedExceptionWarning(ex);
}
});
t.Start();
}
public static void Upgrade(Dictionary <string, IVsProject> projects, UpgradeProgressCallback progressCallback)
{
Dispatcher dispatcher = Dispatcher.CurrentDispatcher;
Thread t = new Thread(() =>
{
var NuGet = Package.Instance.NuGet;
var DTE = Package.Instance.DTE;
var builder = Package.Instance;
int i = 0;
int total = projects.Count;
foreach (var entry in projects)
{
var project = entry.Value;
var dteProject = project.GetDTEProject();
var name = entry.Key;
i++;
if (progressCallback.Canceled)
{
break;
}
dispatcher.Invoke(
new Action(() =>
{
progressCallback.ReportProgress(name, i);
}));
NuGet.Restore(dteProject);
if (!NuGet.IsPackageInstalled(dteProject, Package.NuGetBuilderPackageId))
{
DTE.StatusBar.Text = string.Format("Installing NuGet package {0} in project {1}",
Package.NuGetBuilderPackageId, name);
NuGet.InstallLatestPackage(dteProject, Package.NuGetBuilderPackageId);
}
IceBuilderProjectType projectType = DTEUtil.IsIceBuilderEnabled(project);
if (projectType != IceBuilderProjectType.None)
{
bool cpp = projectType == IceBuilderProjectType.CppProjectType;
DTE.StatusBar.Text = string.Format("Upgrading project {0} Ice Builder settings", project.GetDTEProject().UniqueName);
var msproject = project.GetMSBuildProject();
var fullPath = ProjectUtil.GetProjectFullPath(project);
var assemblyDir = ProjectUtil.GetEvaluatedProperty(project, "IceAssembliesDir");
if (projectType == IceBuilderProjectType.CsharpProjectType)
{
foreach (VSLangProj80.Reference3 r in dteProject.GetProjectRererences())
{
if (Package.AssemblyNames.Contains(r.Name))
{
var item = msproject.AllEvaluatedItems.FirstOrDefault(referenceItem =>
referenceItem.ItemType.Equals("Reference") &&
referenceItem.EvaluatedInclude.Split(",".ToCharArray()).ElementAt(0).Equals(r.Name));
if (item != null)
{
if (item.HasMetadata("HintPath"))
{
var hintPath = item.GetMetadata("HintPath").UnevaluatedValue;
if (hintPath.Contains("$(IceAssembliesDir)"))
{
hintPath = hintPath.Replace("$(IceAssembliesDir)",
FileUtil.RelativePath(Path.GetDirectoryName(r.ContainingProject.FullName), assemblyDir));
//
// If the HintPath points to the NuGet zeroc.ice.net package we upgrade it to not
// use IceAssembliesDir otherwise we remove it
if (hintPath.Contains("packages\\zeroc.ice.net"))
{
item.SetMetadataValue("HintPath", hintPath);
}
else
{
item.RemoveMetadata("HintPath");
}
}
}
}
}
}
}
bool modified = MSBuildUtils.UpgradeProjectImports(msproject);
modified = MSBuildUtils.UpgradeProjectProperties(msproject, cpp) || modified;
modified = MSBuildUtils.RemoveIceBuilderFromProject(msproject, true) || modified;
modified = MSBuildUtils.UpgradeProjectItems(msproject, cpp) || modified;
if (modified)
{
builder.SaveProject(project);
}
}
}
dispatcher.BeginInvoke(new Action(() => progressCallback.Finished()));
});
t.Start();
}
