Entry GetOrCreateEntry(ConfigurationAndPlatform solutionConfiguration)
{
Entry entry;
if (!dict.TryGetValue(solutionConfiguration, out entry)) {
var config = new ConfigurationAndPlatform(solutionConfiguration.Configuration, MSBuildInternals.FixPlatformNameForProject(solutionConfiguration.Platform));
entry = new Entry(config);
dict.Add(solutionConfiguration, entry);
}
return entry;
}
/// <summary>
/// Gets the project configuration corresponding to the given solution configuration.
/// </summary>
public ConfigurationAndPlatform GetProjectConfiguration(ConfigurationAndPlatform solutionConfiguration)
{
lock (dict) {
Entry entry;
if (dict.TryGetValue(solutionConfiguration, out entry)) {
return entry.Config;
} else {
return new ConfigurationAndPlatform(solutionConfiguration.Configuration, MSBuildInternals.FixPlatformNameForProject(solutionConfiguration.Platform));
}
}
}
/// <summary>
/// Sets the project configuration corresponding to the given solution configuration.
/// </summary>
public void SetProjectConfiguration(ConfigurationAndPlatform solutionConfiguration, ConfigurationAndPlatform projectConfiguration)
{
if (string.IsNullOrEmpty(projectConfiguration.Configuration))
throw new ArgumentException("Invalid project configuration");
if (string.IsNullOrEmpty(projectConfiguration.Platform))
throw new ArgumentException("Invalid project platform");
lock (dict) {
GetOrCreateEntry(solutionConfiguration).Config = new ConfigurationAndPlatform(
projectConfiguration.Configuration,
MSBuildInternals.FixPlatformNameForProject(projectConfiguration.Platform)
);
}
Changed(this, EventArgs.Empty);
}
/// <summary>
/// copy properties from g into a new property group for newConfiguration and newPlatform
/// </summary>
void CopyProperties(ProjectRootElement project, ProjectPropertyGroupElement g, ConfigurationAndPlatform newConfig)
{
ProjectPropertyGroupElement ng = project.AddPropertyGroup();
ng.Condition = newConfig.ToCondition();
foreach (var p in g.Properties) {
ng.AddProperty(p.Name, p.Value).Condition = p.Condition;
}
}
void IConfigurationOrPlatformNameCollection.Add(string newName, string copyFrom)
{
SD.MainThread.VerifyAccess();
newName = ValidateName(newName);
if (newName == null)
throw new ArgumentException();
lock (project.SyncRoot) {
var projectFile = project.MSBuildProjectFile;
var userProjectFile = project.MSBuildUserProjectFile;
bool copiedGroupInMainFile = false;
if (copyFrom != null) {
copyFrom = MSBuildInternals.FixPlatformNameForProject(copyFrom);
foreach (ProjectPropertyGroupElement g in projectFile.PropertyGroups.ToList()) {
var gConfig = ConfigurationAndPlatform.FromCondition(g.Condition);
if (HasName(gConfig, copyFrom)) {
CopyProperties(projectFile, g, SetName(gConfig, newName));
copiedGroupInMainFile = true;
}
}
foreach (ProjectPropertyGroupElement g in userProjectFile.PropertyGroups.ToList()) {
var gConfig = ConfigurationAndPlatform.FromCondition(g.Condition);
if (HasName(gConfig, copyFrom)) {
CopyProperties(userProjectFile, g, SetName(gConfig, newName));
}
}
}
if (!copiedGroupInMainFile) {
projectFile.AddPropertyGroup().Condition = (isPlatform ? new ConfigurationAndPlatform(null, newName) : new ConfigurationAndPlatform(newName, null)).ToCondition();
}
project.LoadConfigurationPlatformNamesFromMSBuild();
// Adjust mapping:
// If the new config/platform already exists in the solution and is mapped to some old project config/platform,
// re-map it to the new config/platform.
var mapping = project.ConfigurationMapping;
if (isPlatform) {
string newNameForSolution = MSBuildInternals.FixPlatformNameForSolution(newName);
if (project.ParentSolution.PlatformNames.Contains(newNameForSolution, ConfigurationAndPlatform.ConfigurationNameComparer)) {
foreach (string solutionConfiguration in project.ParentSolution.ConfigurationNames) {
var solutionConfig = new ConfigurationAndPlatform(solutionConfiguration, newNameForSolution);
var projectConfig = mapping.GetProjectConfiguration(solutionConfig);
mapping.SetProjectConfiguration(solutionConfig, SetName(projectConfig, newName));
}
}
} else {
if (project.ParentSolution.ConfigurationNames.Contains(newName, ConfigurationAndPlatform.ConfigurationNameComparer)) {
foreach (string solutionPlatform in project.ParentSolution.PlatformNames) {
var solutionConfig = new ConfigurationAndPlatform(newName, solutionPlatform);
var projectConfig = mapping.GetProjectConfiguration(solutionConfig);
mapping.SetProjectConfiguration(solutionConfig, SetName(projectConfig, newName));
}
}
}
project.ActiveConfiguration = mapping.GetProjectConfiguration(project.ParentSolution.ActiveConfiguration);
}
}
ConfigurationAndPlatform SetName(ConfigurationAndPlatform config, string newName)
{
if (isPlatform)
return new ConfigurationAndPlatform(config.Configuration, newName);
else
return new ConfigurationAndPlatform(newName, config.Platform);
}
void UpdateGrid()
{
inUpdate = true;
solutionConfig = new ConfigurationAndPlatform(configurationComboBox.Text, platformComboBox.Text);
foreach (DataGridViewRow row in grid.Rows) {
IProject p = (IProject)row.Tag;
var projectConfig = p.ConfigurationMapping.GetProjectConfiguration(solutionConfig);
DataGridViewComboBoxCell c1 = (DataGridViewComboBoxCell)row.Cells[1];
SetItemsAndSelect(c1, p.ConfigurationNames, projectConfig.Configuration);
c1.Items.Add(EditTag.Instance);
DataGridViewComboBoxCell c2 = (DataGridViewComboBoxCell)row.Cells[2];
SetItemsAndSelect(c2, p.PlatformNames, projectConfig.Platform);
c2.Items.Add(EditTag.Instance);
}
inUpdate = false;
}
/// <summary>
/// Gets whether deploying the project is enabled in the given solution configuration.
/// </summary>
public bool IsDeployEnabled(ConfigurationAndPlatform solutionConfiguration)
{
lock (dict) {
Entry entry;
if (dict.TryGetValue(solutionConfiguration, out entry)) {
return entry.Deploy;
} else {
return false;
}
}
}
bool TryParseProjectConfigurationKey(string key, out Guid guid, out ConfigurationAndPlatform config)
{
guid = default(Guid);
config = default(ConfigurationAndPlatform);
int firstDot = key.IndexOf('.');
int secondDot = key.IndexOf('.', firstDot + 1);
if (firstDot < 0 || secondDot < 0)
return false;
string guidText = key.Substring(0, firstDot);
if (!Guid.TryParse(guidText, out guid))
return false;
string configKey = key.Substring(firstDot + 1, secondDot - (firstDot + 1));
config = ConfigurationAndPlatform.FromKey(configKey);
return config != default(ConfigurationAndPlatform);
}
bool HasName(ConfigurationAndPlatform config, string name)
{
return ConfigurationAndPlatform.ConfigurationNameComparer.Equals(GetName(config), name);
}
public Entry(ConfigurationAndPlatform config)
{
this.Config = config;
}
/// <summary>
/// Renames an entry.
/// </summary>
public void RenameSolutionConfiguration(ConfigurationAndPlatform sourceSolutionConfiguration, ConfigurationAndPlatform targetSolutionConfiguration)
{
lock (dict) {
Entry entry;
if (dict.TryGetValue(sourceSolutionConfiguration, out entry)) {
dict.Remove(sourceSolutionConfiguration);
dict.Add(targetSolutionConfiguration, entry);
}
}
Changed(this, EventArgs.Empty);
}
/// <summary>
/// Copies an entry.
/// </summary>
public void CopySolutionConfiguration(ConfigurationAndPlatform sourceSolutionConfiguration, ConfigurationAndPlatform targetSolutionConfiguration)
{
lock (dict) {
Entry entry;
if (dict.TryGetValue(sourceSolutionConfiguration, out entry)) {
dict[targetSolutionConfiguration] = entry.Clone();
}
}
Changed(this, EventArgs.Empty);
}
/// <summary>
/// Removes all data stored about the specified solution configuration.
/// </summary>
public void Remove(ConfigurationAndPlatform solutionConfiguration)
{
bool result;
lock (dict) {
result = dict.Remove(solutionConfiguration);
}
if (result)
Changed(this, EventArgs.Empty);
}
/// <summary>
/// Sets whether deploying the project is enabled in the given solution configuration.
/// </summary>
public void SetDeployEnabled(ConfigurationAndPlatform solutionConfiguration, bool value)
{
lock (dict) {
GetOrCreateEntry(solutionConfiguration).Deploy = value;
}
Changed(this, EventArgs.Empty);
}
void AdjustMapping(string oldName, string newName)
{
var mapping = project.ConfigurationMapping;
foreach (string solutionConfiguration in project.ParentSolution.ConfigurationNames) {
foreach (string solutionPlatform in project.ParentSolution.PlatformNames) {
var solutionConfig = new ConfigurationAndPlatform(solutionConfiguration, solutionPlatform);
var projectConfig = mapping.GetProjectConfiguration(solutionConfig);
if (HasName(projectConfig, oldName))
mapping.SetProjectConfiguration(solutionConfig, SetName(projectConfig, newName));
}
}
// Adjust active configuration:
if (HasName(project.ActiveConfiguration, oldName))
project.ActiveConfiguration = SetName(project.ActiveConfiguration, newName);
}
string GetName(ConfigurationAndPlatform config)
{
return isPlatform ? config.Platform : config.Configuration;
}
/// <summary>
/// Gets whether building the project is enabled in the given solution configuration.
/// </summary>
public bool IsBuildEnabled(ConfigurationAndPlatform solutionConfiguration)
{
lock (dict) {
Entry entry;
if (dict.TryGetValue(solutionConfiguration, out entry)) {
return entry.Build;
} else {
return true;
}
}
}
public MSBuildItemDefinitionGroup(MSBuildBasedProject project, ConfigurationAndPlatform configuration)
: this(project, configuration.ToCondition())
{
}
void GridCellValueChanged(object sender, DataGridViewCellEventArgs e)
{
if (!inUpdate && e.RowIndex >= 0) {
DataGridViewRow row = grid.Rows[e.RowIndex];
IProject project = (IProject)row.Tag;
var newConfig = new ConfigurationAndPlatform(
GetValue(row.Cells[configurationColumn.Index]),
GetValue(row.Cells[platformColumn.Index]));
project.ConfigurationMapping.SetProjectConfiguration(solutionConfig, newConfig);
}
}
SolutionSection GenerateProjectConfigurationSection(ISolution solution)
{
SolutionSection section = new SolutionSection("ProjectConfigurationPlatforms", "postSolution");
foreach (var project in solution.Projects) {
foreach (var configuration in solution.ConfigurationNames) {
foreach (var platform in solution.PlatformNames) {
var solutionConfig = new ConfigurationAndPlatform(configuration, platform);
var projectConfig = project.ConfigurationMapping.GetProjectConfiguration(solutionConfig);
string key = GuidToString(project.IdGuid) + "." + solutionConfig;
string value = projectConfig.Configuration + "|" + MSBuildInternals.FixPlatformNameForSolution(projectConfig.Platform);
section.Add(key + ".ActiveCfg", value);
if (project.ConfigurationMapping.IsBuildEnabled(solutionConfig))
section.Add(key + ".Build.0", value);
if (project.ConfigurationMapping.IsDeployEnabled(solutionConfig))
section.Add(key + ".Deploy.0", value);
}
}
}
return section;
}
public Task<BuildResults> BuildAsync(ISolution solution, BuildOptions options)
{
if (solution != null) {
var solutionConfiguration = new ConfigurationAndPlatform(options.SolutionConfiguration ?? solution.ActiveConfiguration.Configuration,
options.SolutionPlatform ?? solution.ActiveConfiguration.Platform);
return BuildAsync(solution.Projects.Where(p => p.ConfigurationMapping.IsBuildEnabled(solutionConfiguration)), options);
} else {
return Task.FromResult(new BuildResults { Result = BuildResultCode.Error });
}
}
