protected override bool OnGetNeedsBuilding (ConfigurationSelector configuration)
{
foreach (Package p in packages)
if (p.NeedsBuilding)
return true;
return false;
}
public async Task<BuildResult> Build (ProgressMonitor monitor, ConfigurationSelector configuration, bool buildReferencedTargets = false, OperationContext operationContext = null)
{
var res = new BuildResult { BuildCount = 0 };
foreach (var bt in Items.OfType<IBuildTarget> ())
res.Append (await bt.Build (monitor, configuration, operationContext:operationContext));
return res;
}
static public void Deploy (AspNetAppProject project, ICollection<WebDeployTarget> targets, ConfigurationSelector configuration)
{
//project needs to be built before it can be deployed
IdeApp.ProjectOperations.Build (project);
//set up and launch a copying thread
DeployThreadParams threadParams = new DeployThreadParams ();
threadParams.Context = new DeployContext (new WebDeployResolver (), null, null);
threadParams.Files = MonoDevelop.Deployment.DeployService.GetDeployFiles (threadParams.Context,
project, configuration);
Dictionary<string, string> taskAliases = new Dictionary<string,string> ();
foreach (WebDeployTarget target in targets) {
threadParams.Targets.Add ((WebDeployTarget) target.Clone ());
taskAliases.Add (target.LocationName, target.GetMarkup ());
}
MultiTaskDialogProgressMonitor monitor = new MultiTaskDialogProgressMonitor (true, true, true, taskAliases);
monitor.SetDialogTitle (MonoDevelop.Core.GettextCatalog.GetString ("Web Deployment Progress"));
monitor.SetOperationTitle (MonoDevelop.Core.GettextCatalog.GetString ("Deploying {0}...", project.Name));
threadParams.Monitor = monitor;
Thread deployThread = new Thread (new ParameterizedThreadStart (DoDeploy));
deployThread.Name = "Web deploy";
deployThread.Start (threadParams);
}
internal protected virtual Task Execute (ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration, SolutionRunConfiguration runConfiguration)
{
context.RunConfiguration = runConfiguration;
#pragma warning disable 618 // Type or member is obsolete
return Execute (monitor, context, configuration);
#pragma warning restore 618 // Type or member is obsolete
}
protected async override Task<BuildResult> OnBuild (ProgressMonitor monitor, ConfigurationSelector configuration, OperationContext operationContext)
{
foreach (Package p in packages)
if (!await p.Build (monitor))
break;
return BuildResult.CreateSuccess ();
}
public override DeployFileCollection GetDeployFiles (DeployContext ctx, SolutionItem entry, ConfigurationSelector configuration)
{
if (entry is IDeployable)
return new DeployFileCollection (((IDeployable)entry).GetDeployFiles (configuration));
return base.GetDeployFiles (ctx, entry, configuration);
}
protected override BuildResult DoBuild (IProgressMonitor monitor, ConfigurationSelector configuration)
{
useOriginalBasePath = true;
var res = base.DoBuild (monitor, configuration);
useOriginalBasePath = false;
return res;
}
public CustomCommandWidget(IWorkspaceObject entry, CustomCommand cmd, ConfigurationSelector configSelector, CustomCommandType[] supportedTypes)
{
this.Build();
this.supportedTypes = supportedTypes;
this.cmd = cmd;
updating = true;
if (cmd == null)
comboType.AppendText (GettextCatalog.GetString ("(Select a project operation)"));
foreach (var ct in supportedTypes)
comboType.AppendText (commandNames [(int)ct]);
updating = false;
this.entry = entry;
UpdateControls ();
this.WidgetFlags |= Gtk.WidgetFlags.NoShowAll;
StringTagModelDescription tagModel;
if (entry is SolutionItem)
tagModel = ((SolutionItem)entry).GetStringTagModelDescription (configSelector);
else if (entry is WorkspaceItem)
tagModel = ((WorkspaceItem)entry).GetStringTagModelDescription ();
else
tagModel = new StringTagModelDescription ();
tagSelectorDirectory.TagModel = tagModel;
tagSelectorDirectory.TargetEntry = workingdirEntry;
tagSelectorCommand.TagModel = tagModel;
tagSelectorCommand.TargetEntry = entryCommand;
}
protected override BuildResult Build (IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration)
{
DotNetProject project = (DotNetProject) entry;
GtkDesignInfo info = GtkDesignInfo.FromProject (project);
// The code generator must run in the GUI thread since it needs to
// access to Gtk classes
Generator gen = new Generator ();
lock (gen) {
Gtk.Application.Invoke (delegate { gen.Run (monitor, project, configuration); });
Monitor.Wait (gen);
}
BuildResult res = base.Build (monitor, entry, configuration);
if (gen.Messages != null) {
foreach (string s in gen.Messages)
// res.AddWarning (info.GuiBuilderProject.File, 0, 0, null, s);
// TODO: Add gtkx file name in the Generator
res.AddWarning ("", 0, 0, null, s);
if (gen.Messages.Length > 0)
info.ForceCodeGenerationOnBuild ();
}
return res;
}
public override DeployFileCollection GetProjectDeployFiles (DeployContext ctx, Project project,
ConfigurationSelector configuration)
{
DeployFileCollection files = base.GetProjectDeployFiles (ctx, project, configuration);
AspNetAppProject aspProj = project as AspNetAppProject;
//none of this needs to happen if it's just happening during solution build
if (aspProj == null || ctx.ProjectBuildOnly)
return files;
//audit the DeployFiles to make sure they're allowed and laid out for ASP.NET
foreach (DeployFile df in files) {
//rewrite ProgramFiles target to ASP.NET's "bin" target
if (df.TargetDirectoryID == TargetDirectory.ProgramFiles) {
df.RelativeTargetPath = Path.Combine ("bin", df.RelativeTargetPath);
}
}
//add all ASP.NET files marked as content. They go relative to the application root, which we assume to be ProgramFiles
foreach (ProjectFile pf in aspProj.Files) {
if (pf.BuildAction == BuildAction.Content)
files.Add (new DeployFile (aspProj, pf.FilePath, pf.ProjectVirtualPath, TargetDirectory.ProgramFiles));
}
return files;
}
internal protected override async Task<List<string>> OnGetReferencedAssemblies (ConfigurationSelector configuration)
{
var res = await base.OnGetReferencedAssemblies (configuration);
var asms = Project.TargetRuntime.AssemblyContext.GetAssemblies (Project.TargetFramework).Where (a => a.Package.IsFrameworkPackage).Select (a => a.Location);
res.AddRange (asms);
return res;
}
public override DeployFileCollection GetProjectDeployFiles (DeployContext ctx, Project project, ConfigurationSelector config)
{
DeployFileCollection col = base.GetProjectDeployFiles (ctx, project, config);
LinuxDeployData data = LinuxDeployData.GetLinuxDeployData (project);
if (ctx.Platform == "Linux") {
DotNetProject netProject = project as DotNetProject;
if (netProject != null) {
DotNetProjectConfiguration conf = netProject.GetConfiguration (config) as DotNetProjectConfiguration;
if (conf != null) {
if (conf.CompileTarget == CompileTarget.Exe || conf.CompileTarget == CompileTarget.WinExe) {
if (data.GenerateScript) {
col.Add (GenerateLaunchScript (ctx, netProject, data, conf));
}
}
if (conf.CompileTarget == CompileTarget.Library || conf.CompiledOutputName.FileName.EndsWith (".dll")) {
if (data.GeneratePcFile) {
col.Add (GeneratePcFile (ctx, netProject, data, conf));
}
}
}
}
}
// If the project is deploying an app.desktop file, rename it to the name of the project.
foreach (DeployFile file in col) {
if (Path.GetFileName (file.RelativeTargetPath) == "app.desktop") {
string dir = Path.GetDirectoryName (file.RelativeTargetPath);
file.RelativeTargetPath = Path.Combine (dir, data.PackageName + ".desktop");
}
}
return col;
}
public virtual IEnumerable<AbstractDProject> GetReferencedDProjects(ConfigurationSelector configuration)
{
AbstractDProject p;
foreach (var dep in References.ReferencedProjectIds)
if ((p = ParentSolution.GetSolutionItem(dep) as AbstractDProject) != null)
yield return p;
}
protected override FilePath OnGetOutputFileName (ConfigurationSelector configuration)
{
var output = base.OnGetOutputFileName (configuration);
if (!disableOutputNameChange && IsSupportedProject)
return output.ChangeExtension (PluginExtension);
return output;
}
protected override Task OnExecute(ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
if (base.OnGetCanExecute(context, configuration))
{
return base.OnExecute(monitor, context, configuration);
}
try
{
var project = Project as DotNetProject;
if (project != null && IsSupportedProject)
{
const string SoftDebuggerName = RhinoSoftDebuggerEngine.DebuggerName;
var config = project.GetConfiguration(configuration) as DotNetProjectConfiguration;
var cmd = new RhinoCommonExecutionCommand(project.GetOutputFileName(configuration), project);
cmd.Arguments = config.CommandLineParameters;
cmd.WorkingDirectory = Path.GetDirectoryName(config.CompiledOutputName);
cmd.EnvironmentVariables = config.GetParsedEnvironmentVariables();
cmd.TargetRuntime = project.TargetRuntime;
cmd.UserAssemblyPaths = project.GetUserAssemblyPaths(configuration);
var executionModes = Runtime.ProcessService.GetExecutionModes();
var executionMode = executionModes.SelectMany(r => r.ExecutionModes).FirstOrDefault(r => r.Id == SoftDebuggerName);
var console = context.ConsoleFactory.CreateConsole(new OperationConsoleFactory.CreateConsoleOptions(true));
var operation = executionMode.ExecutionHandler.Execute(cmd, console);
monitor.CancellationToken.Register(() => operation.Cancel());
return operation.Task;
}
}
catch (Exception ex)
{
monitor.ReportError($"An error occurred starting Rhino.\n{ex}", ex);
}
return null;
}
/// <summary>
/// Flags Unity projects for debugging with this addin
/// </summary>
protected override bool CanExecute (SolutionEntityItem item, ExecutionContext context, ConfigurationSelector configuration)
{
if (CanExecuteProject (item as Project, context)) {
return context.ExecutionHandler.CanExecute (new UnityExecutionCommand (item.BaseDirectory.FullPath));
}
return base.CanExecute (item, context, configuration);
}
public static BuildResult BuildProject(DubProject prj, IProgressMonitor mon, ConfigurationSelector sel)
{
var br = new BuildResult();
// Skip building sourceLibraries
string targetType = null;
var cfg = prj.GetConfiguration (sel) as DubProjectConfiguration;
if (cfg != null){
cfg.BuildSettings.TryGetTargetTypeProperty (prj, sel, ref targetType);
if(string.IsNullOrWhiteSpace(targetType))
prj.CommonBuildSettings.TryGetTargetTypeProperty (prj, sel, ref targetType);
if (targetType != null && targetType.ToLower ().Contains("sourcelibrary")) {
br.BuildCount = 1;
return br;
}
}
var args = new StringBuilder("build");
BuildCommonArgAppendix(args, prj, sel);
string output;
string errDump;
int status = ProjectBuilder.ExecuteCommand(DubSettings.Instance.DubCommand, args.ToString(), prj.BaseDirectory,
mon, out errDump, out output);
br.CompilerOutput = output;
ErrorExtracting.HandleReturnCode (mon, br, status);
ErrorExtracting.HandleCompilerOutput(prj, br, output);
ErrorExtracting.HandleCompilerOutput(prj, br, errDump);
return br;
}
public virtual DeployFileCollection GetCombineDeployFiles (DeployContext ctx, SolutionFolder combine, ConfigurationSelector configuration)
{
if (Next != null)
return Next.GetDeployFiles (ctx, combine, configuration);
else
return new DeployFileCollection ();
}
public virtual DeployFileCollection GetProjectDeployFiles (DeployContext ctx, Project project, ConfigurationSelector configuration)
{
if (Next != null)
return Next.GetDeployFiles (ctx, project, configuration);
else
return new DeployFileCollection ();
}
public static IAsyncOperation Package (MonoMacProject project, ConfigurationSelector configSel,
MonoMacPackagingSettings settings, FilePath target)
{
IProgressMonitor mon = IdeApp.Workbench.ProgressMonitors.GetOutputProgressMonitor (
GettextCatalog.GetString ("Packaging Output"),
MonoDevelop.Ide.Gui.Stock.RunProgramIcon, true, true);
var t = new System.Threading.Thread (() => {
try {
using (mon) {
BuildPackage (mon, project, configSel, settings, target);
}
} catch (Exception ex) {
mon.ReportError ("Unhandled error in packaging", null);
LoggingService.LogError ("Unhandled exception in packaging", ex);
} finally {
mon.Dispose ();
}
}) {
IsBackground = true,
Name = "Mac Packaging",
};
t.Start ();
return mon.AsyncOperation;
}
public override IEnumerable<string> GetSourcePaths (ConfigurationSelector sel)
{
useOriginalBasePath = true;
var en = base.GetSourcePaths (sel).ToList();
useOriginalBasePath = false;
return en;
}
protected override BuildResult Build (IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration)
{
BuildResult res = base.Build (monitor, entry, configuration);
if (res.ErrorCount > 0 || !(entry is DotNetProject))
return res;
DotNetProject project = (DotNetProject) entry;
AddinData data = AddinData.GetAddinData (project);
if (data == null)
return res;
monitor.Log.WriteLine (AddinManager.CurrentLocalizer.GetString ("Verifying add-in description..."));
string fileName = data.AddinManifestFileName;
ProjectFile file = data.Project.Files.GetFile (fileName);
if (file == null)
return res;
string addinFile;
if (file.BuildAction == BuildAction.EmbeddedResource)
addinFile = project.GetOutputFileName (ConfigurationSelector.Default);
else
addinFile = file.FilePath;
AddinDescription desc = data.AddinRegistry.GetAddinDescription (new ProgressStatusMonitor (monitor), addinFile);
StringCollection errors = desc.Verify ();
foreach (string err in errors) {
res.AddError (data.AddinManifestFileName, 0, 0, "", err);
monitor.Log.WriteLine ("ERROR: " + err);
}
return res;
}
protected override void DoExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
IodineConfiguration config = (IodineConfiguration)GetConfiguration (configuration);
IConsole console = config.ExternalConsole ?
context.ExternalConsoleFactory.CreateConsole (!config.PauseConsoleOutput) :
context.ConsoleFactory.CreateConsole (!config.PauseConsoleOutput);
AggregatedOperationMonitor aggregatedMonitor = new AggregatedOperationMonitor (monitor);
try {
string param = string.Format ("\"{0}\" {1}", config.MainFile, config.CommandLineParameters);
IProcessAsyncOperation op = Runtime.ProcessService.StartConsoleProcess ("iodine",
param, BaseDirectory,
config.EnvironmentVariables, console, null);
monitor.CancelRequested += delegate {
op.Cancel ();
};
aggregatedMonitor.AddOperation (op);
op.WaitForCompleted ();
monitor.Log.WriteLine ("Iodine exited with code: " + op.ExitCode);
} catch (Exception e) {
monitor.ReportError (GettextCatalog.GetString ("Cannot execute \"{0}\"", config.MainFile), e);
} finally {
console.Dispose ();
aggregatedMonitor.Dispose ();
}
}
public CustomCommandWidget (IWorkspaceObject entry, CustomCommand cmd, ConfigurationSelector configSelector)
{
this.Build();
this.cmd = cmd;
if (cmd != null) {
updating = true;
comboType.RemoveText (0);
updating = false;
}
this.entry = entry;
UpdateControls ();
this.WidgetFlags |= Gtk.WidgetFlags.NoShowAll;
StringTagModelDescription tagModel;
if (entry is SolutionItem)
tagModel = ((SolutionItem)entry).GetStringTagModelDescription (configSelector);
else if (entry is WorkspaceItem)
tagModel = ((WorkspaceItem)entry).GetStringTagModelDescription ();
else
tagModel = new StringTagModelDescription ();
tagSelectorDirectory.TagModel = tagModel;
tagSelectorDirectory.TargetEntry = workingdirEntry;
tagSelectorCommand.TagModel = tagModel;
tagSelectorCommand.TargetEntry = entryCommand;
}
protected override void Clean (MonoDevelop.Core.IProgressMonitor monitor, SolutionEntityItem item, ConfigurationSelector configuration)
{
var proj = item as MonoGameContentProject;
MonoGameContentProjectConfiguration cfg = null;
if (proj != null)
cfg = proj.GetConfiguration (configuration) as MonoGameContentProjectConfiguration;
if (proj == null) {
monitor.Log.WriteLine("Cleaning for Unknown MonoGame Project");
base.Clean (monitor, item, configuration);
}
var manager = new PipelineManager(proj.BaseDirectory.FullPath,
Path.Combine(cfg.OutputDirectory, cfg.MonoGamePlatform),
cfg.IntermediateOutputDirectory);
monitor.Log.WriteLine("Detected {0} MonoGame Platform", cfg.MonoGamePlatform);
foreach(var file in proj.Files)
{
if (file.BuildAction == "Compile") {
try {
monitor.Log.WriteLine("Cleaning {0}", file.FilePath.FileName);
manager.CleanContent(file.FilePath.FullPath, null);
}
catch(Exception ex)
{
monitor.Log.WriteLine(ex.Message);
}
}
}
base.Clean (monitor, item, configuration);
}
/// <summary>
/// Builds the specified solution item.
/// </summary>
/// <param name = "monitor">The monitor.</param>
/// <param name = "item">The item.</param>
/// <param name = "configuration">The configuration.</param>
/// <returns>The build result.</returns>
protected override BuildResult Build(IProgressMonitor monitor, SolutionEntityItem item, ConfigurationSelector configuration)
{
BuildResult result = new BuildResult ();
// Pre-build
monitor.BeginTask (GettextCatalog.GetString ("Pre-Building..."), 1);
this.PreBuild (result, monitor, item, configuration);
monitor.EndTask();
if (result.ErrorCount > 0) {
return result;
}
// Build
monitor.BeginTask (GettextCatalog.GetString ("Building"), 1);
result.Append (base.Build (monitor, item, configuration));
monitor.EndTask();
if (result.ErrorCount > 0) {
return result;
}
// Post-build
monitor.BeginTask (GettextCatalog.GetString ("Post-Building..."), 1);
this.PostBuild (result, monitor, item, configuration);
monitor.EndTask();
return result;
}
public override IEnumerable<SolutionItem> GetReferencedItems(ConfigurationSelector configuration)
{
SolutionItem p;
foreach (var dep in References.ReferencedProjectIds)
if ((p = ParentSolution.GetSolutionItem(dep)) != null)
yield return p;
}
protected override BuildResult OnBuild (MonoDevelop.Core.IProgressMonitor monitor, ConfigurationSelector configuration)
{
var restResult = RestClient.CompileScripts ();
var result = new BuildResult ();
foreach (var message in restResult.Messages)
{
var file = BaseDirectory + "/" + message.File;
var msg = message.Message;
var errorNum = "";
var messageStrings = message.Message.Split(':');
if (messageStrings.Length == 3)
{
var errorNumStrings = messageStrings[1].Split(' ');
if (errorNumStrings.Length > 1)
errorNum = errorNumStrings[errorNumStrings.Length - 1];
msg = messageStrings[2];
}
if(message.Type == "warning")
result.AddWarning(file, message.Line, message.Column, errorNum, msg);
else
result.AddError(file, message.Line, message.Column, errorNum, msg);
}
return result;
}
protected override ExecutionCommand CreateExecutionCommand (ConfigurationSelector configSel,
DotNetProjectConfiguration configuration)
{
var conf = (MeeGoProjectConfiguration) configuration;
return new MeeGoExecutionCommand (conf) {
UserAssemblyPaths = GetUserAssemblyPaths (configSel),
};
}
public override BuildResult RunTarget (IProgressMonitor monitor, IBuildTarget item, string target, ConfigurationSelector configuration)
{
var solutionItem = item as SolutionItem;
if (solutionItem == null)
return base.RunTarget (monitor, item, target, configuration);
return solutionItem.ParentSolution.Build (monitor, configuration);
}
public bool CanExecute(ExecutionContext context, ConfigurationSelector configuration)
{
return(false);
}
public bool NeedsBuilding(ConfigurationSelector configuration)
{
return(false);
}
public virtual SolutionConfiguration GetConfiguration(ConfigurationSelector configuration)
{
return((SolutionConfiguration)configuration.GetConfiguration(this) ?? DefaultConfiguration);
}
protected virtual IEnumerable <ExecutionTarget> GetExecutionTargets(SolutionEntityItem item, ConfigurationSelector configuration)
{
return(GetNext(item).GetExecutionTargets((IBuildTarget)item, configuration));
}
protected virtual IEnumerable <ExecutionTarget> GetExecutionTargets(Solution solution, ConfigurationSelector configuration)
{
return(GetNext(solution).GetExecutionTargets((IBuildTarget)solution, configuration));
}
protected virtual bool GetNeedsBuilding(Solution item, ConfigurationSelector configuration)
{
return(GetNext(item).GetNeedsBuilding((IBuildTarget)item, configuration));
}
public virtual IEnumerable <string> GetReferencedAssemblies(DotNetProject project, ConfigurationSelector configuration, bool includeProjectReferences)
{
return(GetNext(project).GetReferencedAssemblies(project, configuration, includeProjectReferences));
}
void GetBuildableReferencedItems(List <SolutionItem> referenced, SolutionItem item, ConfigurationSelector configuration)
{
if (referenced.Contains(item))
{
return;
}
if (item.NeedsBuilding(configuration))
{
referenced.Add(item);
}
foreach (SolutionItem ritem in item.GetReferencedItems(configuration))
{
GetBuildableReferencedItems(referenced, ritem, configuration);
}
}
protected internal override void OnExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
ProjectConfiguration config = GetConfiguration(configuration) as ProjectConfiguration;
if (config == null)
{
monitor.ReportError(GettextCatalog.GetString("Configuration '{0}' not found in project '{1}'", configuration, Name), null);
return;
}
DoExecute(monitor, context, configuration);
}
/// <summary>
/// Executes the project
/// </summary>
/// <param name='monitor'>
/// Progress monitor.
/// </param>
/// <param name='context'>
/// Execution context.
/// </param>
/// <param name='configuration'>
/// Configuration to execute.
/// </param>
protected virtual void DoExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
}
/// <summary>
/// Gets the absolute path to the output file generated by this project.
/// </summary>
/// <returns>
/// Absolute path the the output file.
/// </returns>
/// <param name='configuration'>
/// Build configuration.
/// </param>
public virtual FilePath GetOutputFileName(ConfigurationSelector configuration)
{
return(FilePath.Null);
}
protected internal override void OnSetNeedsBuilding(bool value, ConfigurationSelector configuration)
{
isDirty = value;
}
public virtual IEnumerable <ExecutionTarget> GetExecutionTargets(IBuildTarget item, ConfigurationSelector configuration)
{
if (item is SolutionEntityItem)
{
return(GetExecutionTargets((SolutionEntityItem)item, configuration));
}
else if (item is WorkspaceItem)
{
return(GetExecutionTargets((WorkspaceItem)item, configuration));
}
else
{
return(GetNext(item).GetExecutionTargets(item, configuration));
}
}
public void Execute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
throw new System.NotImplementedException();
}
public BuildResult RunTarget(IProgressMonitor monitor, string target, ConfigurationSelector configuration)
{
return(new BuildResult());
}
protected virtual void DoClean(IProgressMonitor monitor, ConfigurationSelector configuration)
{
ItemHandler.RunTarget(monitor, "Clean", configuration);
}
protected virtual void SetNeedsBuilding(Solution item, bool val, ConfigurationSelector configuration)
{
GetNext(item).SetNeedsBuilding((IBuildTarget)item, val, configuration);
}
/// <summary>
/// Builds the project.
/// </summary>
/// <returns>
/// The build result.
/// </returns>
/// <param name='monitor'>
/// Progress monitor.
/// </param>
/// <param name='configuration'>
/// Configuration to build.
/// </param>
/// <remarks>
/// This method is invoked to build the project. Support files such as files with the Copy to Output flag will
/// be copied before calling this method.
/// </remarks>
protected virtual BuildResult DoBuild(IProgressMonitor monitor, ConfigurationSelector configuration)
{
BuildResult res = ItemHandler.RunTarget(monitor, "Build", configuration);
return(res ?? new BuildResult());
}
protected virtual IEnumerable <ExecutionTarget> GetExecutionTargets(WorkspaceItem item, ConfigurationSelector configuration)
{
if (item is Solution)
{
return(GetExecutionTargets((Solution)item, configuration));
}
else
{
return(GetNext(item).GetExecutionTargets((IBuildTarget)item, configuration));
}
}
internal protected override bool OnGetCanExecute(ExecutionContext context, ConfigurationSelector configuration)
{
return(false);
}
internal protected override BuildResult OnRunTarget(IProgressMonitor monitor, string target, ConfigurationSelector configuration)
{
if (target == ProjectService.BuildTarget)
{
SolutionItemConfiguration conf = GetConfiguration(configuration) as SolutionItemConfiguration;
if (conf != null && conf.CustomCommands.HasCommands(CustomCommandType.Build))
{
conf.CustomCommands.ExecuteCommand(monitor, this, CustomCommandType.Build, configuration);
return(new BuildResult());
}
}
else if (target == ProjectService.CleanTarget)
{
SolutionItemConfiguration config = GetConfiguration(configuration) as SolutionItemConfiguration;
if (config != null && config.CustomCommands.HasCommands(CustomCommandType.Clean))
{
config.CustomCommands.ExecuteCommand(monitor, this, CustomCommandType.Clean, configuration);
return(new BuildResult());
}
}
return(base.OnRunTarget(monitor, target, configuration));
}
public void SetNeedsBuilding(bool needsBuilding, ConfigurationSelector configuration)
{
}
protected virtual bool CanExecute(Solution solution, ExecutionContext context, ConfigurationSelector configuration)
{
return(GetNext(solution).CanExecute((IBuildTarget)solution, context, configuration));
}
public ReadOnlyCollection <T> GetAllSolutionItemsWithTopologicalSort <T> (ConfigurationSelector configuration) where T : SolutionItem
{
return(RootFolder.GetAllItemsWithTopologicalSort <T> (configuration));
}
protected virtual void Execute(IProgressMonitor monitor, WorkspaceItem item, ExecutionContext context, ConfigurationSelector configuration)
{
if (item is Solution)
{
Execute(monitor, (Solution)item, context, configuration);
}
else
{
GetNext(item).Execute(monitor, (IBuildTarget)item, context, configuration);
}
}
protected virtual bool CanExecute(WorkspaceItem item, ExecutionContext context, ConfigurationSelector configuration)
{
if (item is Solution)
{
return(CanExecute((Solution)item, context, configuration));
}
else
{
return(GetNext(item).CanExecute((IBuildTarget)item, context, configuration));
}
}
protected virtual void Execute(IProgressMonitor monitor, SolutionEntityItem item, ExecutionContext context, ConfigurationSelector configuration)
{
GetNext(item).Execute(monitor, (IBuildTarget)item, context, configuration);
}
protected virtual bool CanExecute(SolutionEntityItem item, ExecutionContext context, ConfigurationSelector configuration)
{
return(GetNext(item).CanExecute((IBuildTarget)item, context, configuration));
}
public ReadOnlyCollection <Project> GetAllProjectsWithTopologicalSort(ConfigurationSelector configuration)
{
return(RootFolder.GetAllProjectsWithTopologicalSort(configuration));
}
protected virtual void Execute(IProgressMonitor monitor, Solution solution, ExecutionContext context, ConfigurationSelector configuration)
{
GetNext(solution).Execute(monitor, (IBuildTarget)solution, context, configuration);
}