/// <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>
/// 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);
}
}
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);
}
}
/// <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);
}
}
}
/// <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>
/// 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);
}
}
}
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
}));
}
}
internal void LoadPreferences()
{
try {
preferences = SD.PropertyService.LoadExtraProperties(GetPreferencesKey());
} catch (IOException) {
} catch (XmlException) {
// ignore errors about inaccessible or malformed files
}
// Load active configuration from preferences
CreateDefaultConfigurationsIfMissing();
this.ActiveConfiguration = ConfigurationAndPlatform.FromKey(preferences.Get("ActiveConfiguration", "Debug|Any CPU"));
ValidateConfiguration();
// We can't set the startup project property yet; LoadPreferences() is called before
// the projects are loaded into the solution.
// This is necessary so that the projects can be loaded in the correct configuration
// - we avoid an expensive configuration switch during solution load.
}
/// <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);
}
public string ValidateName(string name)
{
if (name == null)
{
return(null);
}
name = name.Trim();
if (!ConfigurationAndPlatform.IsValidName(name))
{
return(null);
}
if (isPlatform)
{
return(MSBuildInternals.FixPlatformNameForProject(name));
}
else
{
return(name);
}
}
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);
}
}
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;
}
void IConfigurationOrPlatformNameCollection.Remove(string name)
{
SD.MainThread.VerifyAccess();
lock (project.SyncRoot) {
string otherName = null;
foreach (string configName in this)
{
if (!ConfigurationAndPlatform.ConfigurationNameComparer.Equals(configName, name))
{
otherName = configName;
break;
}
}
if (otherName == null)
{
throw new InvalidOperationException("cannot remove the last configuration/platform");
}
foreach (ProjectPropertyGroupElement g in project.MSBuildProjectFile.PropertyGroups.Concat(project.MSBuildUserProjectFile.PropertyGroups).ToList())
{
ProjectPropertyElement prop = FindConfigElement(g);
if (prop != null && ConfigurationAndPlatform.ConfigurationNameComparer.Equals(prop.Value, name))
{
prop.Value = otherName;
}
var gConfig = ConfigurationAndPlatform.FromCondition(g.Condition);
if (HasName(gConfig, name))
{
g.Parent.RemoveChild(g);
}
}
project.LoadConfigurationPlatformNamesFromMSBuild();
AdjustMapping(name, otherName);
}
}
internal IEnumerable <ConfigurationAndPlatform> LoadSolutionConfigurations(IEnumerable <KeyValuePair <string, string> > section)
{
// Entries in the section look like this: 'Debug|Any CPU = Debug|Any CPU'
return(section.Select(e => ConfigurationAndPlatform.FromKey(e.Key))
.Where(e => ConfigurationAndPlatform.IsValidName(e.Configuration) && ConfigurationAndPlatform.IsValidName(e.Platform)));
}
public MSBuildItemDefinitionGroup(MSBuildBasedProject project, ConfigurationAndPlatform configuration)
: this(project, configuration.ToCondition())
{
}
public Entry(ConfigurationAndPlatform config)
{
this.Config = config;
}
/// <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;
}
}
bool HasName(ConfigurationAndPlatform config, string name)
{
return(ConfigurationAndPlatform.ConfigurationNameComparer.Equals(GetName(config), name));
}
string GetName(ConfigurationAndPlatform config)
{
return(isPlatform ? config.Platform : config.Configuration);
}
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);
}
}
/// <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);
}
