private object[] CreateList(SolutionItem solutionItem)
{
ArrayList arrayList = new ArrayList();
arrayList.Add("Any");
if (solutionItem.ItemType == SolutionItemType.Solution)
{
SolutionConfigurations solutionConfigurations = solutionItem.Solution.SolutionBuild.SolutionConfigurations;
string a = "";
foreach (SolutionConfiguration solutionConfiguration in solutionConfigurations)
{
if (a != solutionConfiguration.Name)
{
arrayList.Add(solutionConfiguration.Name);
a = solutionConfiguration.Name;
}
}
}
else
{
object[] array = (object[])solutionItem.Project.ConfigurationManager.ConfigurationRowNames;
object[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
object value = array2[i];
arrayList.Add(value);
}
}
return(arrayList.ToArray());
}
/// <summary>
/// Get solution configuration before edit
/// </summary>
private void getSolutionPlarformConfig()
{
DTE dte = _applicationObject as DTE;
SolutionConfigurations SGS = dte.Solution.SolutionBuild.SolutionConfigurations;
foreach (SolutionConfiguration SG in SGS)
{
string name = SG.Name;
SolutionContexts SCS = SG.SolutionContexts;
foreach (SolutionContext SC in SCS)
{
string cname = SC.ConfigurationName;
string pname = SC.PlatformName;
string prname = SC.ProjectName;
configtableentry c = new configtableentry();
c.platform = pname;
c.config = cname;
c.deployable = SC.ShouldDeploy;
configTable.Add(c);
}
}
}
public Solution(ITracer tracer, IVsServiceProvider serviceProvider, PerformanceTracer performanceTracer)
{
Contract.Requires(tracer != null);
Contract.Requires(serviceProvider != null);
Contract.Requires(performanceTracer != null);
_deferredUpdateThrottle = new DispatcherThrottle(DispatcherPriority.ApplicationIdle, Update);
_tracer = tracer;
_serviceProvider = serviceProvider;
_performanceTracer = performanceTracer;
_specificProjectConfigurations = _projects.ObservableSelectMany(prj => prj.SpecificProjectConfigurations);
_solutionContexts = SolutionConfigurations.ObservableSelectMany(cfg => cfg.Contexts);
_projectConfigurations = _projects.ObservableSelectMany(prj => prj.ProjectConfigurations);
_solutionEvents = Dte?.Events?.SolutionEvents;
if (_solutionEvents != null)
{
_solutionEvents.Opened += () => Solution_Changed("Solution opened");
_solutionEvents.AfterClosing += () => Solution_Changed("Solution after closing");
_solutionEvents.ProjectAdded += _ => Solution_Changed("Project added");
_solutionEvents.ProjectRemoved += _ => Solution_Changed("Project removed");
_solutionEvents.ProjectRenamed += (_, __) => Solution_Changed("Project renamed");
}
Update();
}
/// <summary>
/// Set solution config after edit
/// </summary>
private void SolutionPlarformConfig()
{
DTE dte = _applicationObject as DTE;
SolutionConfigurations SGS = dte.Solution.SolutionBuild.SolutionConfigurations;
foreach (SolutionConfiguration SG in SGS)
{
string name = SG.Name;
SolutionContexts SCS = SG.SolutionContexts;
foreach (SolutionContext SC in SCS)
{
string cname = SC.ConfigurationName;
string pname = SC.PlatformName;
string prname = SC.ProjectName;
configtableentry e = configTable.Find(i => (i.config == cname) && (i.platform == pname));
if (e != null)
{
configTable.Remove(e);
}
else
{
SC.ShouldDeploy = true;
}
}
}
}
public Solution(ITracer tracer, IVsServiceProvider serviceProvider)
{
Contract.Requires(tracer != null);
Contract.Requires(serviceProvider != null);
_deferredUpdateThrottle = new DispatcherThrottle(DispatcherPriority.ContextIdle, Update);
_tracer = tracer;
_serviceProvider = serviceProvider;
_specificProjectConfigurations = Projects.ObservableSelectMany(prj => prj.SpecificProjectConfigurations);
_solutionContexts = SolutionConfigurations.ObservableSelectMany(cfg => cfg.Contexts);
_defaultProjectConfigurations = Projects.ObservableSelect(prj => prj.DefaultProjectConfiguration);
_projectConfigurations = new ObservableCompositeCollection <ProjectConfiguration>(_defaultProjectConfigurations, _specificProjectConfigurations);
_solutionEvents = Dte?.Events?.SolutionEvents;
if (_solutionEvents != null)
{
_solutionEvents.Opened += Solution_Changed;
_solutionEvents.AfterClosing += Solution_Changed;
_solutionEvents.ProjectAdded += _ => Solution_Changed();
_solutionEvents.ProjectRemoved += _ => Solution_Changed();
_solutionEvents.ProjectRenamed += (_, __) => Solution_Changed();
}
Update();
}
/// <summary>
/// Creates the list.
/// </summary>
/// <param name="solutionItem">The solution item.</param>
/// <returns>An array of configuration names.</returns>
private object[] CreateList(SolutionItem solutionItem)
{
ArrayList ret = new ArrayList();
ret.Add("Any");
if (solutionItem.ItemType == SolutionItemType.Solution)
{
SolutionConfigurations configs = solutionItem.Solution.SolutionBuild.SolutionConfigurations;
string lastConfigName = "";
foreach (SolutionConfiguration config in configs)
{
if (lastConfigName != config.Name)
{
ret.Add(config.Name);
lastConfigName = config.Name;
}
}
}
else
{
object[] names = (object[])solutionItem.Project.ConfigurationManager.ConfigurationRowNames;
foreach (object o in names)
{
ret.Add(o);
}
}
return(ret.ToArray());
}
/// <summary>
/// Handles the Load event of the ShowDependenciesForm control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void ShowDependenciesForm_Load(object sender, EventArgs e)
{
SolutionConfigurations configurations = null;
if (ServiceLocator.Instance.ShellHelper.Solution != null &&
ServiceLocator.Instance.ShellHelper.Solution.SolutionBuild != null)
{
configurations = ServiceLocator.Instance.ShellHelper.Solution.SolutionBuild.SolutionConfigurations;
}
if (configurations != null && configurations.Count > 0)
{
for (int i = 0; i < configurations.Count; i++)
{
cbMode.Items.Add(configurations.Item(i + 1).Name);
}
}
else
{
cbMode.Items.Add("*");
}
cbMode.SelectedIndex = 0;
// cbAction.Items.Add( ReferenceContext.Action.FromLatest );
cbAction.Items.Add("Repository");
cbAction.Items.Add("current solution");
cbAction.SelectedIndex = 1;
}
private void PostHandleWebResourceProjects(Project project)
{
//Turn off Build option in build configurations
SolutionConfigurations solutionConfigurations = _dte.Solution.SolutionBuild.SolutionConfigurations;
string folderProjectFileName = ProjectWorker.GetFolderProjectFileName(project.FullName);
SolutionWorker.SetBuildConfigurationOff(solutionConfigurations, folderProjectFileName);
}
public VisualStudioProject(EnvDTE.Project nativeProject,
SolutionConfigurations solutionConfigurations)
{
this.nativeProject = nativeProject;
Name = nativeProject.Name;
SetAvailableConfigurations(solutionConfigurations);
}
public VisualStudioProject(EnvDTE.Project nativeProject,
SolutionConfigurations solutionConfigurations)
{
this.nativeProject = nativeProject;
Name = nativeProject.Name;
SetAvailableConfigurations(solutionConfigurations);
}
public void RunFinished()
{
using (StreamWriter sw = new StreamWriter(Path.Combine(destinationDirectory, ".sdktools.props")))
{
sw.WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>");
sw.WriteLine("<Project ToolsVersion=\"14.0\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">");
sw.WriteLine("<PropertyGroup>");
sw.WriteLine(" <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>");
sw.WriteLine($" <TizenSDKDir>{tpath}</TizenSDKDir>");
sw.WriteLine("</PropertyGroup>");
sw.WriteLine("</Project>");
}
// Remove wrong Build directory
Directory.Delete(Path.Combine(destinationDirectory, "Build"), true);
DTE dte = this.projectTizen.DTE;
string configuration = dte.Solution.SolutionBuild.ActiveConfiguration.Name;
string splatform = "";
foreach (Project p in dte.Solution.Projects)
{
string platform = p.ConfigurationManager.ActiveConfiguration.PlatformName;
switch (platform)
{
case "ARM":
case "x86":
splatform = platform;
break;
default:
continue;
}
break;
}
if (splatform == "")
{
splatform = "x86";
}
SolutionConfigurations scs = dte.Solution.SolutionBuild.SolutionConfigurations;
foreach (SolutionConfiguration sc in scs)
{
foreach (SolutionContext c in sc.SolutionContexts)
{
string pn = c.PlatformName;
string cn = c.ConfigurationName;
if (cn == configuration && pn == splatform)
{
sc.Activate();
}
}
}
}
/// <summary>
/// Caches the solution build configs
/// </summary>
private void CacheBuildConfigs()
{
SolutionConfigurations SolutionConfigs =
UnrealVSPackage.Instance.DTE.Solution.SolutionBuild.SolutionConfigurations;
SolutionConfigPlatforms =
(from SolutionConfiguration2 Sc in SolutionConfigs select Sc.PlatformName).Distinct().ToArray();
SolutionConfigNames =
(from SolutionConfiguration2 Sc in SolutionConfigs select Sc.Name).Distinct().ToArray();
}
private void SynchronizeCollections(bool retryOnErrors)
{
Projects.SynchronizeWith(GetProjects(retryOnErrors).ToArray());
SolutionConfigurations.SynchronizeWith(GetConfigurations().ToArray());
ProjectProperties.SynchronizeWith(GetProjectProperties().ToArray());
ProjectTypeGuids.SynchronizeWith(Projects.SelectMany(p => p.ProjectTypeGuids).ToArray());
UpdateReferences();
}
private void SetAvailableConfigurations(SolutionConfigurations solutionConfigurations)
{
foreach (SolutionConfiguration2 solutionConfiguration in solutionConfigurations)
{
string configuration = solutionConfiguration.Name;
string platform = solutionConfiguration.PlatformName;
foreach (SolutionContext solutionContext in solutionConfiguration.SolutionContexts)
if (solutionContext.ProjectName == nativeProject.UniqueName)
AvailableConfigurations.Add(new VisualStudioConfiguration(solutionContext,
nativeProject.ConfigurationManager, configuration, platform));
}
}
public IReadOnlyList <string> GetSolutionBuildConfigurations()
{
List <string> solutionConfigurationNames = new List <string>();
SolutionConfigurations solutionConfigurations = _hierarchy.GetDTEProject().DTE.Solution.SolutionBuild.SolutionConfigurations;
foreach (SolutionConfiguration2 config in solutionConfigurations)
{
solutionConfigurationNames.Add(config.Name);
}
return(solutionConfigurationNames);
}
public static bool SetActiveSolutionConfiguration(string ConfigName, string PlatformName)
{
SolutionConfigurations DteSolutionConfigs = UnrealVSPackage.Instance.DTE.Solution.SolutionBuild.SolutionConfigurations;
foreach (SolutionConfiguration2 SolutionConfig in DteSolutionConfigs)
{
if (string.Compare(SolutionConfig.Name, ConfigName, StringComparison.Ordinal) == 0 &&
string.Compare(SolutionConfig.PlatformName, PlatformName, StringComparison.Ordinal) == 0)
{
SolutionConfig.Activate();
return(true);
}
}
return(false);
}
private void SetAvailableConfigurations(SolutionConfigurations solutionConfigurations)
{
foreach (SolutionConfiguration2 solutionConfiguration in solutionConfigurations)
{
string configuration = solutionConfiguration.Name;
string platform = solutionConfiguration.PlatformName;
foreach (SolutionContext solutionContext in solutionConfiguration.SolutionContexts)
{
if (solutionContext.ProjectName == nativeProject.UniqueName)
{
AvailableConfigurations.Add(new VisualStudioConfiguration(solutionContext,
nativeProject.ConfigurationManager, configuration, platform));
}
}
}
}
public static void CreateConfigurationsForAllProjectTargets(IEnumerable <string> targets, Project project)
{
Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread();
if (targets == null || !targets.Any())
{
return;
}
//*****create a 'target-specific build' solution configuration if not available
Solution solution = project.DTE.Solution;
SolutionConfigurations solutionConfigurations = solution.SolutionBuild.SolutionConfigurations;
SolutionConfiguration2 targetSpecificConfiguration = solutionConfigurations.OfType <SolutionConfiguration2>()
.Where(config => config.Name.Equals(targetBuildConfigName)).FirstOrDefault();
if (targetSpecificConfiguration == null)
{
targetSpecificConfiguration = solutionConfigurations.Add(targetBuildConfigName, string.Empty, false) as SolutionConfiguration2;
if (targetSpecificConfiguration == null)
{
return;
}
}
foreach (string target in targets)
{
CreateConfigurationsForTarget(target, project);
}
//***** set project configuration for solution configuration
foreach (SolutionContext context in targetSpecificConfiguration.SolutionContexts)
{
if (context.ProjectName == project.UniqueName)
{
if (context.ConfigurationName.Equals("Release - all Targets", StringComparison.OrdinalIgnoreCase) ||
context.ConfigurationName.Equals("Debug - all Targets", StringComparison.OrdinalIgnoreCase))
{
context.ConfigurationName = string.Format(releaseConfigurationNameRaw, targets.First());
break;
}
}
}
}
public static void SetBuildConfigurationOff(SolutionConfigurations buildConfigurations, string projectName)
{
foreach (SolutionConfiguration buildConfiguration in buildConfigurations)
{
if (!string.Equals(buildConfiguration.Name, Resource.Constant_ProjectBuildConfig_Debug, StringComparison.CurrentCultureIgnoreCase) &&
!string.Equals(buildConfiguration.Name, Resource.Constant_ProjectBuildConfig_Release, StringComparison.CurrentCultureIgnoreCase))
{
continue;
}
SolutionContexts contexts = buildConfiguration.SolutionContexts;
foreach (SolutionContext solutionContext in contexts)
{
if (solutionContext.ProjectName == projectName)
{
solutionContext.ShouldBuild = false;
}
}
}
}
public static void SetBuildConfigurationOff(SolutionConfigurations buildConfigurations, string projectName)
{
foreach (SolutionConfiguration buildConfiguration in buildConfigurations)
{
//Localize these?
if (buildConfiguration.Name != "Debug" && buildConfiguration.Name != "Release")
{
continue;
}
SolutionContexts contexts = buildConfiguration.SolutionContexts;
foreach (SolutionContext solutionContext in contexts)
{
if (solutionContext.ProjectName == projectName)
{
solutionContext.ShouldBuild = false;
}
}
}
}
public static void GetSolutionConfigsAndPlatforms(out string[] SolutionConfigs, out string[] SolutionPlatforms)
{
var UniqueConfigs = new List <string>();
var UniquePlatforms = new List <string>();
SolutionConfigurations DteSolutionConfigs = UnrealVSPackage.Instance.DTE.Solution.SolutionBuild.SolutionConfigurations;
foreach (SolutionConfiguration2 SolutionConfig in DteSolutionConfigs)
{
if (!UniqueConfigs.Contains(SolutionConfig.Name))
{
UniqueConfigs.Add(SolutionConfig.Name);
}
if (!UniquePlatforms.Contains(SolutionConfig.PlatformName))
{
UniquePlatforms.Add(SolutionConfig.PlatformName);
}
}
SolutionConfigs = UniqueConfigs.ToArray();
SolutionPlatforms = UniquePlatforms.ToArray();
}
private async Task SetProjects()
{
var loadedProjects = new List <Project>();
await Task.Run(() =>
{
SolutionConfigurations solutionConfigurations = GetSolutionConfigurations();
var nativeProjects = new List <EnvDTE.Project>();
NavigateSolution(nativeProjects);
nativeProjects = nativeProjects.OrderBy(p => p.Name).ToList();
foreach (var nativeProject in nativeProjects.Select((x, i) => new { Value = x, Index = i }))
{
StatusText = FormatProjectLoadingMessage(nativeProjects.Count, nativeProject.Index,
nativeProject.Value.Name);
loadedProjects.Add(new VisualStudioProject(nativeProject.Value, solutionConfigurations));
}
});
foreach (Project loadedProject in loadedProjects)
{
Projects.Add(loadedProject);
}
UpdateProjectsSolutionContext();
}
public AsyncCodeConfiguration ConfigureSolution(string solutionFilePath, Action <IFluentSolutionConfiguration> action)
{
if (solutionFilePath == null)
{
throw new ArgumentNullException(nameof(solutionFilePath));
}
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
if (!File.Exists(solutionFilePath))
{
throw new FileNotFoundException($"Solution not found. Path:'{solutionFilePath}'");
}
var solutionConfig = SolutionConfigurations.FirstOrDefault(o => o.Path == solutionFilePath);
if (solutionConfig == null)
{
solutionConfig = new SolutionConfiguration(solutionFilePath);
SolutionConfigurations.Add(solutionConfig);
}
action(solutionConfig);
return(this);
}
private List <SolutionInfo> VerifySolution(EnvDTE.DTE dte)
{
logger.Info("Checking the solution file");
// Verfify the target platform
if (Platform == "Any CPU")
{
logger.Error("Platform 'Any CPU' is not supported.");
return(null);
}
// Verify that project configurations are same.
logger.Info(" Verifying that the configurations of the solution and projects match.");
var slnBuild = dte.Solution.SolutionBuild as SolutionBuild2;
if (TargetConfigurations == null)
{
TargetConfigurations = slnBuild.SolutionConfigurations
.Cast <SolutionConfiguration2>()
.Where(x => x.PlatformName == Platform)
.Select(x => x.Name).ToArray();
}
var projectNamesList = new List <List <string> >();
var cfgNamesList = new List <List <(string slnCfgName, string prjCfgName)> >();
SolutionConfigurations slnCfgs = slnBuild.SolutionConfigurations;
foreach (SolutionConfiguration2 slnCfg in slnCfgs)
{
if (slnCfg.PlatformName != Platform ||
!TargetConfigurations.Contains(slnCfg.Name))
{
continue;
}
var projectNames = new List <string>();
var cfgNames =
new List <(string slnCfgName, string projectCfgName)>();
foreach (SolutionContext context in slnCfg.SolutionContexts)
{
if (!context.ShouldBuild)
{
continue;
}
if (context.PlatformName != Platform)
{
logger.Error($"The platform of {context.ProjectName} does not match {Platform}.");
return(null);
}
if (context.ConfigurationName != slnCfg.Name)
{
logger.Info($" Configuration of {context.ProjectName} does not match ones of the solution.");
logger.Info($" Solution: {slnCfg.Name}");
logger.Info($" Project: {context.ConfigurationName}");
logger.Info($" The configuration name '{context.ConfigurationName}' is replaced by '{slnCfg.Name}'.");
}
projectNames.Add(context.ProjectName);
cfgNames.Add((slnCfg.Name, context.ConfigurationName));
}
if (projectNames.Count == 0)
{
logger.Error(
$"No project to build contains in configuration {slnCfg.Name}");
return(null);
}
projectNamesList.Add(projectNames);
cfgNamesList.Add(cfgNames);
}
if (projectNamesList.Count == 0)
{
logger.Error($"The solution file does not contain C/C++ projects on platform {Platform}.");
return(null);
}
for (int i = 0; i < projectNamesList.Count; i++)
{
projectNamesList[i].Sort();
if (i > 0)
{
if (!projectNamesList[i].SequenceEqual(projectNamesList[0]))
{
logger.Error($"The project configurations are different.");
return(null);
}
}
}
//
string slnDir = Path.GetDirectoryName(dte.Solution.FullName);
var projectsFullPath = projectNamesList[0].ConvertAll(
x => Utility.NormalizePath(Path.Combine(slnDir, x))
.ToLower());
Projects projects = dte.Solution.Projects;
// Verifying existance of VC++ project, and platform.
var solutionInfoList = new List <SolutionInfo>();
foreach (Project project in projects)
{
System.Console.WriteLine(project.Name);
System.Console.WriteLine(project.FileName);
System.Console.WriteLine(project.FullName);
VCProject vcprj = project.Object as VCProject;
if (vcprj == null)
{
logger.Warn(
$"Project '{project.Name}' is not a Visual C++ project.");
continue;
}
var index = projectsFullPath.FindIndex(
x => x == project.FullName.ToLower());
if (index < 0)
{
continue;
}
var solutionInfo = new SolutionInfo();
solutionInfo.project = project;
solutionInfo.cfgs = cfgNamesList.Select(
x => (x[index].slnCfgName, x[index].prjCfgName)).ToArray();
solutionInfoList.Add(solutionInfo);
}
if (solutionInfoList.Count() == 0)
{
logger.Error("No Visual C++ projects to build.");
return(null);
}
logger.Info("Checking the solution file - done");
return(solutionInfoList);
}
public SolutionConfigurationsNodeFactory(SolutionConfigurations solutionConfigurations)
{
_solutionConfigurations = solutionConfigurations;
}
public static void ExecuteProjectBuild(Project Project,
string SolutionConfig,
string SolutionPlatform,
BatchBuilderToolControl.BuildJob.BuildJobType BuildType,
Action ExecutingDelegate,
Action FailedToStartDelegate)
{
IVsHierarchy ProjHierarchy = Utils.ProjectToHierarchyObject(Project);
if (ProjHierarchy != null)
{
SolutionConfigurations SolutionConfigs =
UnrealVSPackage.Instance.DTE.Solution.SolutionBuild.SolutionConfigurations;
var MatchedSolutionConfig =
(from SolutionConfiguration2 Sc in SolutionConfigs select Sc).FirstOrDefault(
Sc =>
String.CompareOrdinal(Sc.Name, SolutionConfig) == 0 && String.CompareOrdinal(Sc.PlatformName, SolutionPlatform) == 0);
if (MatchedSolutionConfig != null)
{
SolutionContext ProjectSolutionCtxt = MatchedSolutionConfig.SolutionContexts.Item(Project.UniqueName);
if (ProjectSolutionCtxt != null)
{
IVsCfgProvider2 CfgProvider2 = Utils.HierarchyObjectToCfgProvider(ProjHierarchy);
if (CfgProvider2 != null)
{
IVsCfg Cfg;
CfgProvider2.GetCfgOfName(ProjectSolutionCtxt.ConfigurationName, ProjectSolutionCtxt.PlatformName, out Cfg);
if (Cfg != null)
{
if (ExecutingDelegate != null)
{
ExecutingDelegate();
}
int JobResult = VSConstants.E_FAIL;
if (BuildType == BatchBuilderToolControl.BuildJob.BuildJobType.Build)
{
JobResult =
UnrealVSPackage.Instance.SolutionBuildManager.StartUpdateSpecificProjectConfigurations(
1,
new[] { ProjHierarchy },
new[] { Cfg },
null,
new uint[] { 0 },
null,
(uint)VSSOLNBUILDUPDATEFLAGS.SBF_OPERATION_BUILD,
0);
}
else if (BuildType == BatchBuilderToolControl.BuildJob.BuildJobType.Rebuild)
{
JobResult =
UnrealVSPackage.Instance.SolutionBuildManager.StartUpdateSpecificProjectConfigurations(
1,
new[] { ProjHierarchy },
new[] { Cfg },
new uint[] { 0 },
null,
null,
(uint)(VSSOLNBUILDUPDATEFLAGS.SBF_OPERATION_BUILD | VSSOLNBUILDUPDATEFLAGS.SBF_OPERATION_FORCE_UPDATE),
0);
}
else if (BuildType == BatchBuilderToolControl.BuildJob.BuildJobType.Clean)
{
JobResult =
UnrealVSPackage.Instance.SolutionBuildManager.StartUpdateSpecificProjectConfigurations(
1,
new[] { ProjHierarchy },
new[] { Cfg },
new uint[] { 0 },
null,
null,
(uint)VSSOLNBUILDUPDATEFLAGS.SBF_OPERATION_CLEAN,
0);
}
if (JobResult == VSConstants.S_OK)
{
// Job running - show output
PrepareOutputPane();
}
else
{
if (FailedToStartDelegate != null)
{
FailedToStartDelegate();
}
}
}
}
}
}
}
}
