public ExecutionContext (IExecutionHandler executionHandler, IConsoleFactory consoleFactory, ExecutionTarget target)
{
var targetedHandler = executionHandler as ITargetedExecutionHandler;
if (targetedHandler != null)
target = targetedHandler.Target ?? target;
this.executionHandler = executionHandler;
this.consoleFactory = consoleFactory;
this.executionTarget = target;
}
public void SetExecutionTarget(SolutionItem project, ExecutionTarget target)
{
if (target == null)
{
list.Remove(project);
}
else
{
list [project] = target;
}
//id = string.Join ("/", list.Select (p => p.Value.Id).OrderBy (id => id));
}
/// <summary>
/// Gets the full configuration name given a possibly merged configuration name and execution target
/// </summary>
/// <param name='currentConfig'>
/// A configuration name (can be a merged configuration name)
/// </param>
/// <param name='currentTarget'>
/// Selected execution target
/// </param>
/// <param name='resolvedConfig'>
/// Resolved configuration
/// </param>
/// <param name='resolvedTarget'>
/// If the provided target is not valid for the provided configuration, this returns a valid target
/// </param>
public void ResolveConfiguration (string currentConfig, ExecutionTarget currentTarget, out string resolvedConfig, out ExecutionTarget resolvedTarget)
{
resolvedConfig = null;
resolvedTarget = currentTarget;
if (!reducedConfigurations.Contains (currentConfig)) {
// The selected configuration is not reduced, just use it as full config name
resolvedConfig = currentConfig;
var part = currentTargetPartitions.FirstOrDefault (p => p.SolutionConfigurations.Contains (currentConfig));
if (part != null) {
if (!ExecutionTargetsContains (part.Targets, resolvedTarget))
resolvedTarget = FirstRealExecutionTarget (part.Targets);
} else {
resolvedTarget = null;
}
} else {
// Reduced configuration. Find the partition and guess the implicit project configuration
var part = currentTargetPartitions.FirstOrDefault (p => ExecutionTargetsContains (p.Targets, currentTarget ?? dummyExecutionTarget));
if (part != null) {
resolvedConfig = part.SolutionConfigurations.FirstOrDefault (c => {
string name, plat;
ItemConfiguration.ParseConfigurationId (c, out name, out plat);
return name == currentConfig;
});
}
if (resolvedConfig == null) {
part = currentTargetPartitions.FirstOrDefault (p => p.ReducedConfigurations.Contains (currentConfig));
if (part == null)
part = currentTargetPartitions.FirstOrDefault (p => p.SolutionConfigurations.Contains (currentConfig));
if (part != null) {
resolvedTarget = FirstRealExecutionTarget (part.Targets);
resolvedConfig = part.SolutionConfigurations.FirstOrDefault (c => {
string name, plat;
ItemConfiguration.ParseConfigurationId (c, out name, out plat);
return name == currentConfig;
});
if (resolvedConfig == null)
resolvedConfig = currentConfig;
} else {
resolvedTarget = null;
resolvedConfig = currentConfig;
}
}
}
if (resolvedTarget == dummyExecutionTarget)
resolvedTarget = null;
}
static bool ExecutionTargetsContains (IEnumerable<ExecutionTarget> targets, ExecutionTarget desired)
{
foreach (var target in targets) {
if (target == desired)
return true;
if ((target is ExecutionTargetGroup) && ExecutionTargetsContains ((ExecutionTargetGroup) target, desired))
return true;
}
return false;
}
public TargetedExecutionHandler (IExecutionHandler handler, ExecutionTarget target)
{
Target = target;
Handler = handler;
}
public RuntimeMutableModel (ExecutionTarget target, bool hasParent)
{
Enabled = !(target is ExecutionTargetGroup);
Visible = true;
if (target == null)
DisplayString = FullDisplayString = string.Empty;
else {
FullDisplayString = target.FullName;
DisplayString = !hasParent ? target.FullName : target.Name;
}
}
public RuntimeModel (MainToolbarController controller, ExecutionTarget target, RuntimeModel parent) : this (controller, target)
{
if (parent == null)
HasParent = false;
else {
HasParent = true;
parent.HasChildren = true;
parent.AddChild (this);
}
}
public RuntimeModel (MainToolbarController controller, ExecutionTarget target) : this (controller)
{
ExecutionTarget = target;
}
public RuntimeModel (MainToolbarController controller, ExecutionTarget target, bool fullText, SolutionItem project) : this (controller)
{
if (target == null)
throw new ArgumentNullException (nameof (target));
ExecutionTarget = target;
this.fullText = fullText;
Project = project;
}
bool CurrentExecutionTargetIsCoreClr(ExecutionTarget executionTarget)
{
var dnxExecutionTarget = executionTarget as DnxExecutionTarget;
if (dnxExecutionTarget != null) {
return dnxExecutionTarget.IsCoreClr ();
}
return false;
}
public ExecutionContext (IExecutionMode executionMode, IConsoleFactory consoleFactory, ExecutionTarget target)
: this (executionMode.ExecutionHandler, consoleFactory, target)
{
}
public RuntimeModel (MainToolbarController controller, ExecutionTarget target) : this (controller)
{
ExecutionTarget = target;
Enabled = !(ExecutionTarget is ExecutionTargetGroup);
Visible = true;
}
bool SelectActiveRuntime (ref bool selected, ref ExecutionTarget defaultTarget, ref int defaultIter)
{
var runtimes = ToolbarView.RuntimeModel.Cast<RuntimeModel> ().ToList ();
for (int iter = 0; iter < runtimes.Count; ++iter) {
var item = runtimes [iter];
if (!item.Enabled)
continue;
var target = item.ExecutionTarget;
if (target == null || !target.Enabled)
continue;
if (target is ExecutionTargetGroup)
if (item.HasChildren)
continue;
if (defaultTarget == null) {
defaultTarget = target;
defaultIter = iter;
}
if (target.Id == IdeApp.Workspace.PreferredActiveExecutionTarget) {
IdeApp.Workspace.ActiveExecutionTarget = target;
ToolbarView.ActiveRuntime = ToolbarView.RuntimeModel.ElementAt (iter);
UpdateBuildConfiguration ();
selected = true;
return true;
}
if (target.Equals (IdeApp.Workspace.ActiveExecutionTarget)) {
ToolbarView.ActiveRuntime = ToolbarView.RuntimeModel.ElementAt (iter);
UpdateBuildConfiguration ();
selected = true;
}
}
return false;
}
public ExecutionContext (IExecutionHandler executionHandler, IConsoleFactory consoleFactory, ExecutionTarget target = null)
{
this.executionHandler = executionHandler;
this.consoleFactory = consoleFactory;
this.executionTarget = target;
}
/// <summary>
/// Load configuration information for a solution
/// </summary>
public void Load (Solution sol, SolutionItem project, SolutionItemRunConfiguration runConfig)
{
currentSolutionConfigurations.Clear ();
currentTargetPartitions.Clear ();
reducedConfigurations.Clear ();
if (sol == null)
return;
// Create a set of configuration partitions. Each partition will contain configurations
// which are implicitly selected when selecting an execution target. For example, in
// an iOS project we would have two partitions:
// 1) Debug|IPhoneSimulator, Release|IPhoneSimulator
// targets: iPhone, iPad
// 2) Debug|IPhone, Release|IPhone
// targets: device
List<TargetPartition> partitions = new List<TargetPartition> ();
if (project != null) {
foreach (var conf in project.Configurations) {
var targets = project.GetExecutionTargets (conf.Selector, runConfig);
if (!targets.Any ()) {
targets = new ExecutionTarget[] { dummyExecutionTarget };
}
var parts = partitions.Where (p => targets.Any (p.Targets.Contains)).ToArray();
if (parts.Length == 0) {
// Create a new partition for this configuration
var p = new TargetPartition ();
p.Configurations.Add (conf.Id);
p.Targets.UnionWith (targets);
partitions.Add (p);
}
else if (parts.Length == 1) {
// Register the configuration into an existing partition
parts[0].Configurations.Add (conf.Id);
parts[0].Targets.UnionWith (targets);
}
else {
// The partitions have to be merged into a single one
for (int n=1; n<parts.Length; n++) {
parts[0].Configurations.UnionWith (parts[n].Configurations);
parts[0].Targets.UnionWith (parts[n].Targets);
partitions.Remove (parts[n]);
}
}
}
// The startup project configuration partitions are used to create solution configuration partitions
foreach (var solConf in sol.Configurations) {
var pconf = solConf.GetEntryForItem (project);
if (pconf != null && pconf.Build) {
var part = partitions.FirstOrDefault (p => p.Configurations.Contains (pconf.ItemConfiguration));
if (part != null) {
part.SolutionConfigurations.Add (solConf.Id);
continue;
}
}
// The solution configuration is not bound to the startup project
// Add it to all partitions so that it can still take part of
// the solution configuration simplification process
foreach (var p in partitions)
p.SolutionConfigurations.Add (solConf.Id);
}
}
if (partitions.Count == 0) {
// There is no startup project, just use all solution configurations in this case
var p = new TargetPartition ();
p.SolutionConfigurations.AddRange (sol.GetConfigurations ());
partitions.Add (p);
}
// There can be several configurations with the same prefix and different platform but which build the same projects.
// If all configurations with the same prefix are identical, all of them can be reduced into a single configuration
// with no platform name. This loop detects such configurations
var notReducibleConfigurations = new HashSet<string> ();
foreach (var p in partitions) {
var groupedConfigs = p.SolutionConfigurations.GroupBy (sc => {
string name, plat;
ItemConfiguration.ParseConfigurationId (sc, out name, out plat);
return name;
}).ToArray ();
foreach (var confGroup in groupedConfigs) {
var configs = confGroup.ToArray ();
var baseConf = sol.Configurations[configs[0]];
if (configs.Skip (1).All (c => ConfigurationEquals (sol, baseConf, sol.Configurations[c])))
p.ReducedConfigurations.Add (confGroup.Key);
else
notReducibleConfigurations.Add (confGroup.Key);
}
}
// To really be able to use reduced configuration names, all partitions must have that reduced configuration
// Find the configurations that have been reduced in all partitions
reducedConfigurations = new HashSet<string> (partitions.SelectMany (p => p.ReducedConfigurations));
reducedConfigurations.ExceptWith (notReducibleConfigurations);
// Final merge of configurations
var result = new HashSet<string> ();
foreach (var p in partitions)
result.UnionWith (p.SolutionConfigurations);
// Replace reduced configurations
foreach (var reducedConf in reducedConfigurations) {
result.RemoveWhere (c => {
string name, plat;
ItemConfiguration.ParseConfigurationId (c, out name, out plat);
return name == reducedConf;
});
result.Add (reducedConf);
}
currentTargetPartitions = partitions;
currentSolutionConfigurations.AddRange (result);
currentSolutionConfigurations.Sort ();
}
bool SelectActiveRuntime (ref bool selected, ref ExecutionTarget defaultTarget, ref int defaultIter)
{
var runtimes = ToolbarView.RuntimeModel.Cast<RuntimeModel> ().ToList ();
string lastRuntimeForProject = currentStartupProject.UserProperties.GetValue<string> ("PreferredExecutionTarget", defaultValue: null);
var activeTarget = IdeApp.Workspace.ActiveExecutionTarget;
var activeTargetId = activeTarget != null ? activeTarget.Id : null;
for (int iter = 0; iter < runtimes.Count; ++iter) {
var item = runtimes [iter];
using (var model = item.GetMutableModel ()) {
if (!model.Enabled)
continue;
}
var target = item.ExecutionTarget;
if (target == null || !target.Enabled)
continue;
if (target is ExecutionTargetGroup)
if (item.HasChildren)
continue;
if (defaultTarget == null || lastRuntimeForProject == target.Id) {
defaultTarget = target;
defaultIter = iter;
}
if (target.Id == activeTargetId) {
IdeApp.Workspace.ActiveExecutionTarget = target;
ToolbarView.ActiveRuntime = ToolbarView.RuntimeModel.ElementAt (iter);
UpdateBuildConfiguration ();
selected = true;
return true;
}
if (target.Equals (activeTarget)) {
ToolbarView.ActiveRuntime = ToolbarView.RuntimeModel.ElementAt (iter);
UpdateBuildConfiguration ();
selected = true;
}
}
return false;
}
bool SelectActiveRuntime (TreeIter iter, ref bool selected, ref ExecutionTarget defaultTarget, ref TreeIter defaultIter)
{
do {
var target = (ExecutionTarget) runtimeStore.GetValue (iter, RuntimeExecutionTarget);
if (target == null)
continue;
if (target is ExecutionTargetGroup) {
TreeIter child;
if (runtimeStore.IterHasChild (iter) && runtimeStore.IterChildren (out child, iter)) {
if (SelectActiveRuntime (child, ref selected, ref defaultTarget, ref defaultIter))
return true;
}
continue;
}
if (defaultTarget == null) {
defaultTarget = target;
defaultIter = iter;
}
if (target.Id == IdeApp.Workspace.PreferredActiveExecutionTarget) {
IdeApp.Workspace.ActiveExecutionTarget = target;
runtimeCombo.SetActiveIter (iter);
UpdateBuildConfiguration ();
selected = true;
return true;
}
if (target.Equals (IdeApp.Workspace.ActiveExecutionTarget)) {
runtimeCombo.SetActiveIter (iter);
UpdateBuildConfiguration ();
selected = true;
}
} while (runtimeStore.IterNext (ref iter));
return false;
}
public ExecutionContext (IExecutionMode executionMode, IConsoleFactory consoleFactory, ExecutionTarget target)
{
this.executionHandler = executionMode.ExecutionHandler;
this.consoleFactory = consoleFactory;
this.executionTarget = target;
}
