public static void GenerateExecutionModeCommands(SolutionEntityItem project, CanExecuteDelegate runCheckDelegate, CommandArrayInfo info) { CommandExecutionContext ctx = new CommandExecutionContext (project, runCheckDelegate); bool supportsParameterization = false; foreach (List<IExecutionMode> modes in GetExecutionModeCommands (ctx, false, true)) { foreach (IExecutionMode mode in modes) { CommandInfo ci = info.Add (mode.Name, new CommandItem (ctx, mode)); if ((mode.ExecutionHandler is ParameterizedExecutionHandler) || ((mode is CustomExecutionMode) && ((CustomExecutionMode)mode).PromptForParameters)) { // It will prompt parameters, so we need command to end with '..'. // However, some commands may end with '...' already and we don't want to break // already-translated strings by altering them if (!ci.Text.EndsWith ("...")) ci.Text += "..."; supportsParameterization = true; } else { // The parameters window will be shown if ctrl is pressed ci.Description = GettextCatalog.GetString ("Run With: {0}", ci.Text); if (SupportsParameterization (mode, ctx)) { ci.Description += " - " + GettextCatalog.GetString ("Hold Control key to display the execution parameters dialog."); supportsParameterization = true; } } } if (info.Count > 0) info.AddSeparator (); } if (supportsParameterization) { info.AddSeparator (); info.Add (GettextCatalog.GetString ("Edit Custom Modes..."), new CommandItem (ctx, null)); } }
internal IProcessAsyncOperation InternalExecute (CommandExecutionContext ctx, IExecutionMode mode, ExecutionCommand command, IConsole console) { CustomExecutionMode cmode = ExecutionModeCommandService.ShowParamtersDialog (ctx, mode, null); if (cmode == null) return new CancelledProcessAsyncOperation (); return cmode.Execute (command, console, false, false); }
internal static IEnumerable<ExecutionCommandCustomizer> GetExecutionCommandCustomizers (CommandExecutionContext ctx) { ExecutionCommand cmd = ctx.GetTargetCommand (); if (cmd == null) yield break; foreach (ExecutionCommandCustomizer customizer in AddinManager.GetExtensionNodes ("/MonoDevelop/Ide/ExecutionCommandEditors", typeof(ExecutionCommandCustomizer))) { if (customizer.CanCustomize (cmd)) yield return customizer; } }
public Gtk.Widget Load (CommandExecutionContext ctx, object data) { if (data != null) { CustomArgsExecutionModeData cdata = (CustomArgsExecutionModeData) data; entryArgs.Text = cdata.Arguments; folderEntry.Path = cdata.WorkingDirectory; envVarList.LoadValues (cdata.EnvironmentVariables); } return this; }
public Gtk.Widget Load (CommandExecutionContext ctx, object data) { config = (MonoExecutionParameters) data; if (config != null) config = config.Clone (); else config = new MonoExecutionParameters (); propertyGrid.CurrentObject = config; return this; }
public void Load (CommandExecutionContext ctx, bool includeDefault, bool includeDefaultCustomizer, ExecutionModeIncludeFilter filter) { bool separate = false; foreach (List<IExecutionMode> modeList in ExecutionModeCommandService.GetExecutionModeCommands (ctx, includeDefault, includeDefaultCustomizer)) { bool addedSome = false; foreach (IExecutionMode mode in modeList) { if (filter == null || filter (mode)) { if (separate) { modes.Add (null); comboMode.AppendText ("--"); separate = false; } modes.Add (mode); comboMode.AppendText (mode.Name); addedSome = true; } } separate = addedSome; } }
public CustomExecutionModeManagerDialog (CommandExecutionContext ctx) { this.Build (); this.ctx = ctx; store = new Gtk.ListStore (typeof(CustomExecutionMode), typeof(string), typeof(string), typeof(string), typeof(string)); listModes.Model = store; Gtk.CellRendererText crt = new Gtk.CellRendererText (); listModes.AppendColumn (GettextCatalog.GetString ("Name"), crt, "text", 1); listModes.AppendColumn (GettextCatalog.GetString ("Execution Mode"), crt, "text", 2); listModes.AppendColumn (GettextCatalog.GetString ("Available for"), crt, "text", 3); listModes.Selection.Changed += delegate { UpdateButtons (); }; treeState = new TreeViewState (listModes, 4); Fill (); }
public void Initialize (CommandExecutionContext ctx, IExecutionMode modeToExecute, CustomExecutionMode data) { this.ctx = ctx; this.data = data; if (this.data == null) this.data = new CustomExecutionMode (); if (modeToExecute != null) { // The user is running the project and the selected mode requires arguments comboTargetMode.Load (ctx, true, false); comboTargetMode.SelectedMode = modeToExecute; mode = modeToExecute; editMode = false; buttonOk.Label = Gtk.Stock.Execute; } else if (data != null) { // Editing an existing custom mode comboTargetMode.Load (ctx, true, false); mode = comboTargetMode.SelectedMode = data.Mode; checkSave.Visible = false; checkPrompt.Visible = boxName.Visible = true; checkPrompt.Active = data.PromptForParameters; entryModeName.Text = data.Name; comboStore.Active = (int) data.Scope; } else { // Creating a new mode comboTargetMode.Load (ctx, true, false); comboTargetMode.SelectedMode = null; checkSave.Visible = false; boxName.Visible = true; checkPrompt.Visible = true; buttonOk.Sensitive = false; // Until name is intered } LoadEditors (); nameChanged = false; }
public override IProcessAsyncOperation Execute(ExecutionCommand command, IConsole console, CommandExecutionContext ctx, object config_data) { DotNetExecutionCommand dnec = command as DotNetExecutionCommand; ProfileConfiguration config = new ProfileConfiguration (); config.TargetPath = command.CommandString; ProfilerExecutionOptions options = config_data as ProfilerExecutionOptions; if (options != null) { config.StartEnabled = options.StartEnabled; config.Mode = options.Mode; } string logfile = System.IO.Path.GetTempFileName () + ".mprof"; ProfilerSocket socket = new ProfilerSocket (); ProfilerViewContent view = new ProfilerViewContent (); socket.Paused += delegate { view.Load (logfile); }; dnec.RuntimeArguments += String.Format (" --profile=logging:{0},o={1},cp={2}", config.ToArgs (), logfile, socket.Port); IExecutionHandler h = Runtime.ProcessService.GetDefaultExecutionHandler (command); IProcessAsyncOperation result = h.Execute (command, console); result.Completed += delegate { view.Load (logfile); }; Gtk.Application.Invoke (delegate { IdeApp.Workbench.OpenDocument (view, true); }); return result; }
public CommandItem(CommandExecutionContext context, IExecutionMode mode) { Context = context; Mode = mode; }
static bool SupportsParameterization(IExecutionMode mode, CommandExecutionContext ctx) { if (ExecutionModeCommandService.GetExecutionCommandCustomizers (ctx).Any ()) return true; return mode.ExecutionHandler is ParameterizedExecutionHandler; }
internal static CustomExecutionMode ShowParamtersDialog(CommandExecutionContext ctx, IExecutionMode mode, CustomExecutionMode currentMode) { CustomExecutionMode cmode = null; DispatchService.GuiSyncDispatch (delegate { CustomExecutionModeDialog dlg = new CustomExecutionModeDialog (); try { dlg.Initialize (ctx, mode, currentMode); if (MessageService.RunCustomDialog (dlg) == (int) Gtk.ResponseType.Ok) { cmode = dlg.GetConfigurationData (); cmode.Project = ctx.Project; if (dlg.Save) SaveCustomCommand (ctx.Project, cmode); } } finally { dlg.Destroy (); } }); return cmode; }
/// <summary> /// Runs a command /// </summary> /// <param name="command"> /// Command to run /// </param> /// <param name="console"> /// The console where to redirect the output /// </param> /// <param name="ctx"> /// Context with execution information /// </param> /// <param name="configurationData"> /// Configuration information. Created by the IExecutionConfigurationEditor object. /// </param> public abstract IProcessAsyncOperation Execute(ExecutionCommand command, IConsole console, CommandExecutionContext ctx, object configurationData);
internal static List <List <IExecutionMode> > GetExecutionModeCommands(CommandExecutionContext ctx, bool includeDefault, bool includeDefaultCustomizer) { List <List <IExecutionMode> > itemGroups = new List <List <IExecutionMode> > (); List <CustomExecutionMode> customModes = new List <CustomExecutionMode> (GetCustomModes(ctx)); foreach (IExecutionModeSet mset in Runtime.ProcessService.GetExecutionModes()) { List <IExecutionMode> items = new List <IExecutionMode> (); HashSet <string> setModes = new HashSet <string> (); foreach (IExecutionMode mode in mset.ExecutionModes) { if (!ctx.CanExecute(mode.ExecutionHandler)) { continue; } setModes.Add(mode.Id); if (mode.Id != "Default" || includeDefault) { items.Add(mode); } if (mode.Id == "Default" && includeDefaultCustomizer && SupportsParameterization(mode, ctx)) { CustomExecutionMode cmode = new CustomExecutionMode(); cmode.Mode = mode; cmode.Project = ctx.Project; cmode.PromptForParameters = true; cmode.Name = GettextCatalog.GetString("Custom Parameters..."); items.Add(cmode); } } List <CustomExecutionMode> toRemove = new List <CustomExecutionMode> (); foreach (CustomExecutionMode cmode in customModes) { if (setModes.Contains(cmode.Mode.Id)) { if (ctx.CanExecute(cmode.Mode.ExecutionHandler)) { items.Add(cmode); } toRemove.Add(cmode); } } foreach (CustomExecutionMode cmode in toRemove) { customModes.Remove(cmode); } if (items.Count > 0) { itemGroups.Add(items); } } if (customModes.Count > 0) { List <IExecutionMode> items = new List <IExecutionMode> (); foreach (CustomExecutionMode cmode in customModes) { if (ctx.CanExecute(cmode.ExecutionHandler)) { items.Add(cmode); } } if (items.Count > 0) { itemGroups.Add(items); } } return(itemGroups); }
public static void GenerateExecutionModeCommands(SolutionItem project, CanExecuteDelegate runCheckDelegate, CommandArrayInfo info) { CommandExecutionContext ctx = new CommandExecutionContext(project, runCheckDelegate); bool supportsParameterization = false; foreach (List <IExecutionMode> modes in GetExecutionModeCommands(ctx, false, true)) { foreach (IExecutionMode mode in modes) { CommandInfo ci = info.Add(mode.Name, new CommandItem(ctx, mode)); if ((mode.ExecutionHandler is ParameterizedExecutionHandler) || ((mode is CustomExecutionMode) && ((CustomExecutionMode)mode).PromptForParameters)) { // It will prompt parameters, so we need command to end with '..'. // However, some commands may end with '...' already and we don't want to break // already-translated strings by altering them if (!ci.Text.EndsWith("...")) { ci.Text += "..."; } supportsParameterization = true; } else { // The parameters window will be shown if ctrl is pressed ci.Description = GettextCatalog.GetString("Run With: {0}", ci.Text); if (SupportsParameterization(mode, ctx)) { ci.Description += " - " + GettextCatalog.GetString("Hold Control key to display the execution parameters dialog."); supportsParameterization = true; } } } if (info.Count > 0) { info.AddSeparator(); } } var targets = new List <ExecutionTarget> (); if (project != null) { FlattenExecutionTargets(targets, project.GetExecutionTargets(IdeApp.Workspace.ActiveConfiguration)); } if (targets.Count > 1) { foreach (var t in targets) { var h = new TargetedExecutionHandler(Runtime.ProcessService.DefaultExecutionHandler, t); CommandInfo ci = info.Add(t.FullName, new CommandItem(ctx, new ExecutionMode(t.Id, t.FullName, h))); ci.Description = GettextCatalog.GetString("Run With: {0}", ci.Text); } info.AddSeparator(); } if (supportsParameterization) { info.AddSeparator(); info.Add(GettextCatalog.GetString("Edit Custom Modes..."), new CommandItem(ctx, null)); } }
internal static IEnumerable <ExecutionCommandCustomizer> GetExecutionCommandCustomizers(CommandExecutionContext ctx) { ExecutionCommand cmd = ctx.GetTargetCommand(); if (cmd == null) { yield break; } foreach (ExecutionCommandCustomizer customizer in AddinManager.GetExtensionNodes("/MonoDevelop/Ide/ExecutionCommandEditors", typeof(ExecutionCommandCustomizer))) { if (customizer.CanCustomize(cmd)) { yield return(customizer); } } }
internal bool Resolve (IRunTarget item) { if (RunConfiguration != null && Mode != null) return true; RunConfiguration = item.GetRunConfigurations ().FirstOrDefault (co => co.Id == runConfigurationId); if (RunConfiguration == null) return false; var ctx = new CommandExecutionContext (item, h => item.CanExecute (new MonoDevelop.Projects.ExecutionContext (h, null, IdeApp.Workspace.ActiveExecutionTarget), IdeApp.Workspace.ActiveConfiguration, RunConfiguration)); IExecutionModeSet modeSet; IExecutionMode mode; if (!ExecutionModeCommandService.GetExecutionMode (ctx, executionModeId, out modeSet, out mode)) return false; ModeSet = modeSet; Mode = mode; return true; }
public void Load (CommandExecutionContext ctx, bool includeDefault, bool includeDefaultCustomizer) { Load (ctx, includeDefault, includeDefaultCustomizer, null); }
internal static bool GetExecutionMode (CommandExecutionContext ctx, string id, out IExecutionModeSet modeSet, out IExecutionMode mode) { foreach (IExecutionModeSet mset in Runtime.ProcessService.GetExecutionModes ()) { foreach (IExecutionMode m in mset.ExecutionModes) { if (m.Id == id && ctx.CanExecute (m.ExecutionHandler)) { modeSet = mset; mode = m; return true; } } } modeSet = null; mode = null; return false; }
void LoadModes () { storeModes.Clear (); var currentMode = SelectedExecutionMode; bool nodeSelected = false; var ctx = new CommandExecutionContext (item, h => item.CanExecute (new ExecutionContext (h, null, IdeApp.Workspace.ActiveExecutionTarget), IdeApp.Workspace.ActiveConfiguration, SelectedConfiguration)); foreach (var modeSet in Runtime.ProcessService.GetExecutionModes ()) { TreeNavigator setNode = null; foreach (var mode in modeSet.ExecutionModes) { if (ctx.CanExecute (mode.ExecutionHandler)) { if (setNode == null) { setNode = storeModes.AddNode (); setNode.SetValue (modeNameField, modeSet.Name); setNode.SetValue (modeField, mode); setNode.SetValue (modeSetField, modeSet); if (mode.Id == currentMode?.Id) { treeModes.SelectRow (setNode.CurrentPosition); nodeSelected = true; } } var node = storeModes.AddNode (setNode.CurrentPosition); node.SetValue (modeNameField, mode.Name); node.SetValue (modeField, mode); node.SetValue (modeSetField, modeSet); if (!nodeSelected && mode.Id == currentMode?.Id) { treeModes.SelectRow (node.CurrentPosition); nodeSelected = true; } } } // If the mode only has one child, remove it, we don't need to show it if (setNode != null && setNode.MoveToChild ()) { var pos = setNode.Clone (); if (!setNode.MoveNext ()) pos.Remove (); } } if (!nodeSelected && storeModes.GetFirstNode ()?.CurrentPosition != null) treeModes.SelectRow (storeModes.GetFirstNode ().CurrentPosition); }
/// <summary> /// Runs a command /// </summary> /// <param name="command"> /// Command to run /// </param> /// <param name="console"> /// The console where to redirect the output /// </param> /// <param name="ctx"> /// Context with execution information /// </param> /// <param name="configurationData"> /// Configuration information. Created by the IExecutionConfigurationEditor object. /// </param> public abstract IProcessAsyncOperation Execute (ExecutionCommand command, IConsole console, CommandExecutionContext ctx, object configurationData);
public static IExecutionMode GetExecutionMode(CommandExecutionContext ctx, string id) { foreach (IExecutionMode mode in GetExecutionModes (ctx)) { if (mode.Id == id) return mode; } return null; }
public static IEnumerable<IExecutionMode> GetExecutionModes(CommandExecutionContext ctx) { foreach (IExecutionModeSet mset in Runtime.ProcessService.GetExecutionModes ()) { foreach (IExecutionMode mode in mset.ExecutionModes) { if (ctx.CanExecute (mode.ExecutionHandler)) yield return mode; } } foreach (CustomExecutionMode mode in GetCustomModes (ctx)) { if (ctx.CanExecute (mode)) yield return mode; } }
List<ExecutionConfiguration> GetExecutionConfigurations () { var ctx = new CommandExecutionContext (project, h => project.CanExecute (new ExecutionContext (h, null, IdeApp.Workspace.ActiveExecutionTarget), IdeApp.Workspace.ActiveConfiguration, runConfig)); var res = new List<ExecutionConfiguration> (); foreach (var modeSet in Runtime.ProcessService.GetExecutionModes ()) { foreach (var mode in modeSet.ExecutionModes) { if (ctx.CanExecute (mode.ExecutionHandler)) res.Add (new ExecutionConfiguration (runConfig, modeSet, mode)); } } return res; }
internal static IEnumerable<CustomExecutionMode> GetCustomModes(CommandExecutionContext ctx) { if (ctx.Project != null) { CustomExecutionModes modes = ctx.Project.UserProperties.GetValue<CustomExecutionModes> ("MonoDevelop.Ide.CustomExecutionModes", GetDataContext ()); if (modes != null) { foreach (CustomExecutionMode mode in modes.Data) { mode.Project = ctx.Project; if (ctx.CanExecute (mode.ExecutionHandler)) { mode.Scope = CustomModeScope.Project; yield return mode; } } } modes = ctx.Project.ParentSolution.UserProperties.GetValue<CustomExecutionModes> ("MonoDevelop.Ide.CustomExecutionModes", GetDataContext ()); if (modes != null) { foreach (CustomExecutionMode mode in modes.Data) { mode.Project = ctx.Project; if (ctx.CanExecute (mode.ExecutionHandler)) { mode.Scope = CustomModeScope.Solution; yield return mode; } } } } foreach (CustomExecutionMode mode in GetGlobalCustomExecutionModes ().Data) { if (ctx.CanExecute (mode.ExecutionHandler)) { mode.Scope = CustomModeScope.Global; yield return mode; } } }
public IProcessAsyncOperation Execute (ExecutionCommand command, IConsole console, bool allowPrompt, bool forcePrompt) { if ((PromptForParameters || forcePrompt) && allowPrompt) { var ctx = new CommandExecutionContext (Project, command); CustomExecutionMode customMode = ExecutionModeCommandService.ShowParamtersDialog (ctx, Mode, this); if (customMode == null) return new CancelledProcessAsyncOperation (); return customMode.Execute (command, console, false, false); } foreach (var cc in GetCachedCustomizers ()) { cc.Item1.Customize (command, cc.Item2); } var cmode = Mode.ExecutionHandler as ParameterizedExecutionHandler; if (cmode != null) { CommandExecutionContext ctx = new CommandExecutionContext (Project, command); return cmode.Execute (command, console, ctx, Data); } return Mode.ExecutionHandler.Execute (command, console); }
internal static List<List<IExecutionMode>> GetExecutionModeCommands(CommandExecutionContext ctx, bool includeDefault, bool includeDefaultCustomizer) { List<List<IExecutionMode>> itemGroups = new List<List<IExecutionMode>> (); List<CustomExecutionMode> customModes = new List<CustomExecutionMode> (GetCustomModes (ctx)); foreach (IExecutionModeSet mset in Runtime.ProcessService.GetExecutionModes ()) { List<IExecutionMode> items = new List<IExecutionMode> (); HashSet<string> setModes = new HashSet<string> (); foreach (IExecutionMode mode in mset.ExecutionModes) { if (!ctx.CanExecute (mode.ExecutionHandler)) continue; setModes.Add (mode.Id); if (mode.Id != "Default" || includeDefault) items.Add (mode); if (mode.Id == "Default" && includeDefaultCustomizer && SupportsParameterization (mode, ctx)) { CustomExecutionMode cmode = new CustomExecutionMode (); cmode.Mode = mode; cmode.Project = ctx.Project; cmode.PromptForParameters = true; cmode.Name = GettextCatalog.GetString ("Custom Parameters..."); items.Add (cmode); } } List<CustomExecutionMode> toRemove = new List<CustomExecutionMode> (); foreach (CustomExecutionMode cmode in customModes) { if (setModes.Contains (cmode.Mode.Id)) { if (ctx.CanExecute (cmode.Mode.ExecutionHandler)) items.Add (cmode); toRemove.Add (cmode); } } foreach (CustomExecutionMode cmode in toRemove) customModes.Remove (cmode); if (items.Count > 0) itemGroups.Add (items); } if (customModes.Count > 0) { List<IExecutionMode> items = new List<IExecutionMode> (); foreach (CustomExecutionMode cmode in customModes) { if (ctx.CanExecute (cmode.ExecutionHandler)) items.Add (cmode); } if (items.Count > 0) itemGroups.Add (items); } return itemGroups; }
public Gtk.Widget Load(CommandExecutionContext ctx, object config_data) { options = config_data as ProfilerExecutionOptions; if (options == null) options = new ProfilerExecutionOptions (); else options = options.Clone (); VBox result = new VBox (false, 0); HBox box = new HBox (false, 6); box = new HBox (false, 6); box.PackStart (new Label ("Mode:"), false, false, 0); ComboBox type_combo = ComboBox.NewText (); type_combo.AppendText ("Allocations"); type_combo.AppendText ("Calls/Instrumented"); type_combo.AppendText ("Statistical"); type_combo.Active = 2; type_combo.Changed += delegate { options.Mode = (ProfileMode) (1 << type_combo.Active); }; box.PackStart (type_combo, false, false, 0); box.ShowAll (); result.PackStart (box, false, false, 3); box = new HBox (false, 6); CheckButton start_enabled_chkbtn = new CheckButton ("Enable Logging at Startup"); start_enabled_chkbtn.Active = true; start_enabled_chkbtn.Toggled += delegate { options.StartEnabled = start_enabled_chkbtn.Active; }; box.PackStart (start_enabled_chkbtn, false, false, 0); box.ShowAll (); result.PackStart (box, false, false, 3); return result; }
public IProcessAsyncOperation Execute (ExecutionCommand command, IConsole console, bool allowPrompt, bool forcePrompt) { if ((PromptForParameters || forcePrompt) && allowPrompt) { CommandExecutionContext ctx = new CommandExecutionContext (Project, command); CustomExecutionMode customMode = ExecutionModeCommandService.ShowParamtersDialog (ctx, Mode, this); if (customMode == null) return new CancelledProcessAsyncOperation (); else return customMode.Execute (command, console, false, false); } if (commandData != null) { foreach (KeyValuePair<string,object> cmdData in commandData) { ExecutionCommandCustomizer cc = ExecutionModeCommandService.GetExecutionCommandCustomizer (cmdData.Key); if (cc != null) cc.Customize (command, cmdData.Value); } } ParameterizedExecutionHandler cmode = Mode.ExecutionHandler as ParameterizedExecutionHandler; if (cmode != null) { CommandExecutionContext ctx = new CommandExecutionContext (Project, command); return cmode.Execute (command, console, ctx, Data); } else return Mode.ExecutionHandler.Execute (command, console); }