public MDSubMenuItem (CommandManager manager, CommandEntrySet ces)
{
this.ces = ces;
this.Submenu = new MDMenu (manager, ces);
this.Title = this.Submenu.Title;
}
public MenuButtonEntry (Gtk.Entry entry, Gtk.Button button)
{
if (entry == null) entry = new Gtk.Entry ();
if (button == null) button = new Gtk.Button (new Gtk.Arrow (Gtk.ArrowType.Right, Gtk.ShadowType.Out));
this.entry = entry;
this.button = button;
manager = new CommandManager ();
manager.RegisterGlobalHandler (this);
if (entry.Parent == null)
PackStart (entry, true, true, 0);
if (button.Parent == null)
PackStart (button, false, false, 2);
ActionCommand cmd = new ActionCommand ("InsertOption", "InsertOption", null);
cmd.CommandArray = true;
manager.RegisterCommand (cmd);
entrySet = new CommandEntrySet ();
entrySet.AddItem ("InsertOption");
button.Clicked += ShowQuickInsertMenu;
button.StateChanged += ButtonStateChanged;
}
public static void Add (this DockItemToolbar toolbar, CommandEntrySet entrySet, Gtk.Widget commandTarget)
{
CommandDockBar dockBar = new CommandDockBar (toolbar, commandTarget);
foreach (CommandEntry entry in entrySet) {
dockBar.Add (entry);
}
}
public CommandEntrySet AddItemSet(string name, IconId icon)
{
CommandEntrySet cmdset = new CommandEntrySet(name, icon);
cmds.Add(cmdset);
return(cmdset);
}
public MDSubMenuItem (CommandManager manager, CommandEntrySet ces, CommandSource commandSource = CommandSource.MainMenu, object initialCommandTarget = null)
{
this.ces = ces;
this.Submenu = new MDMenu (manager, ces, commandSource, initialCommandTarget);
this.Title = this.Submenu.Title;
}
protected override void OnPanelClick (Gdk.EventButton e, Placement placement)
{
if (e.TriggersContextMenu ()) {
CommandEntrySet opset = new CommandEntrySet ();
opset.AddItem (CommandSystemCommands.ToolbarList);
Gtk.Menu menu = manager.CreateMenu (opset);
menu.Popup (null, null, null, 0, e.Time);
}
base.OnPanelClick (e, placement);
}
protected override void OnRealized()
{
base.OnRealized();
if (commandEntrySet != null)
{
manager.CreateMenu(commandEntrySet, this);
Update();
commandEntrySet = null;
}
}
protected override void OnPanelClick(Gdk.EventButton e, Placement placement)
{
if (e.Button == 3)
{
CommandEntrySet opset = new CommandEntrySet();
opset.AddItem(CommandSystemCommands.ToolbarList);
Gtk.Menu menu = manager.CreateMenu(opset);
menu.Popup(null, null, null, 0, e.Time);
}
base.OnPanelClick(e, placement);
}
void EnsurePopulated ()
{
if (populated)
return;
populated = true;
if (commandEntrySet != null) {
manager.CreateMenu (commandEntrySet, this);
Update ();
commandEntrySet = null;
}
}
public MDMenu (CommandManager manager, CommandEntrySet ces, CommandSource commandSource, object initialCommandTarget)
{
this.WeakDelegate = this;
AutoEnablesItems = false;
Title = (ces.Name ?? "").Replace ("_", "");
foreach (CommandEntry ce in ces) {
if (ce.CommandId == Command.Separator) {
AddItem (NSMenuItem.SeparatorItem);
if (!string.IsNullOrEmpty (ce.OverrideLabel))
AddItem (new MDMenuHeaderItem (ce.OverrideLabel));
continue;
}
if (string.Equals (ce.CommandId as string, servicesID, StringComparison.Ordinal)) {
AddItem (new MDServicesMenuItem ());
continue;
}
var subset = ce as CommandEntrySet;
if (subset != null) {
AddItem (new MDSubMenuItem (manager, subset, commandSource, initialCommandTarget));
continue;
}
var lce = ce as LinkCommandEntry;
if (lce != null) {
AddItem (new MDLinkMenuItem (lce));
continue;
}
Command cmd = manager.GetCommand (ce.CommandId);
if (cmd == null) {
LoggingService.LogError ("MacMenu: '{0}' maps to null command", ce.CommandId);
continue;
}
if (cmd is CustomCommand) {
LoggingService.LogWarning ("MacMenu: '{0}' is unsupported custom-rendered command' '", ce.CommandId);
continue;
}
var acmd = cmd as ActionCommand;
if (acmd == null) {
LoggingService.LogWarning ("MacMenu: '{0}' has unknown command type '{1}'", cmd.GetType (), ce.CommandId);
continue;
}
AddItem (new MDMenuItem (manager, ce, acmd, commandSource, initialCommandTarget));
}
}
void EnsurePopulated()
{
if (populated)
{
return;
}
populated = true;
if (commandEntrySet != null)
{
manager.CreateMenu(commandEntrySet, this);
Update();
commandEntrySet = null;
}
}
CommandEntrySet MyPostProcessor(CommandEntrySet input)
{
var toRemove = new List<CommandEntry> ();
foreach(CommandEntry ce in input)
{
var theSet = ce as CommandEntrySet;
if (theSet != null)
MyPostProcessor (theSet);
var id = ce.CommandId as string;
if (isBlackListed (id))
toRemove.Add (ce);
}
// foreach (var r in toRemove)
// input.Remove (r);
return input;
}
public override object CreateInstance ()
{
if (label == null) label = Id;
label = StringParserService.Parse (label);
if (icon != null) icon = CommandCodon.GetStockId (Addin, icon);
CommandEntrySet cset = new CommandEntrySet (label, icon);
cset.CommandId = Id;
cset.AutoHide = autohide;
foreach (InstanceExtensionNode e in ChildNodes) {
CommandEntry ce = e.CreateInstance () as CommandEntry;
if (ce != null)
cset.Add (ce);
else
throw new InvalidOperationException ("Invalid ItemSet child: " + e);
}
return cset;
}
protected override void Run ()
{
var doc = MonoDevelop.Ide.IdeApp.Workbench.ActiveDocument;
var view = doc.GetContent<MonoDevelop.SourceEditor.SourceEditorView> ();
if (view == null) {
LoggingService.LogWarning ("ShowFixesHandler could not find a SourceEditorView");
return;
}
var widget = view.TextEditor;
var pt = view.DocumentToScreenLocation (doc.Editor.Caret.Location);
var ces = new CommandEntrySet ();
ces.AddItem (AnalysisCommands.FixOperations);
var menu = MonoDevelop.Ide.IdeApp.CommandService.CreateMenu (ces);
menu.Popup (null, null, delegate (Menu mn, out int x, out int y, out bool push_in) {
x = pt.X;
y = pt.Y;
push_in = true;
//if the menu would be off the bottom of the screen, "drop" it upwards
if (y + mn.Requisition.Height > widget.Screen.Height)
y -= mn.Requisition.Height + (int)widget.LineHeight;
}, 0, Global.CurrentEventTime);
}
/* public Gtk.Toolbar CreateToolbar (CommandEntrySet entrySet)
{
return CreateToolbar ("", entrySet);
}
*/
/// <summary>
/// Appends commands to a menu
/// </summary>
/// <returns>
/// The menu.
/// </returns>
/// <param name='entrySet'>
/// Entry set with the command definitions
/// </param>
/// <param name='menu'>
/// The menu where to add the commands
/// </param>
public Gtk.Menu CreateMenu (CommandEntrySet entrySet, CommandMenu menu)
{
foreach (CommandEntry entry in entrySet) {
Gtk.MenuItem mi = entry.CreateMenuItem (this);
CustomItem ci = mi.Child as CustomItem;
if (ci != null)
ci.SetMenuStyle (menu);
menu.Append (mi);
}
return menu;
}
/// <summary>
/// Creates a menu bar.
/// </summary>
/// <returns>
/// The menu bar.
/// </returns>
/// <param name='name'>
/// Unused
/// </param>
/// <param name='entrySet'>
/// Entry set with the definition of the commands to be included in the menu bar
/// </param>
public Gtk.MenuBar CreateMenuBar (string name, CommandEntrySet entrySet)
{
Gtk.MenuBar topMenu = new CommandMenuBar (this);
foreach (CommandEntry entry in entrySet) {
Gtk.MenuItem mi = entry.CreateMenuItem (this);
CustomItem ci = mi.Child as CustomItem;
if (ci != null)
ci.SetMenuStyle (topMenu);
topMenu.Append (mi);
}
return topMenu;
}
/// <summary>
/// Creates a command entry set.
/// </summary>
/// <returns>
/// The command entry set.
/// </returns>
/// <param name='addinPath'>
/// Extension path with the command definitions
/// </param>
public CommandEntrySet CreateCommandEntrySet (string addinPath)
{
CommandEntrySet cset = new CommandEntrySet ();
object[] items = AddinManager.GetExtensionObjects (addinPath, false);
foreach (CommandEntry e in items)
cset.Add (e);
return cset;
}
/// <summary>
/// Shows the context menu for a TreeView.
/// </summary>
/// <returns><c>true</c>, if context menu was shown, <c>false</c> otherwise.</returns>
/// <param name="tree">Gtk TreeView for which the context menu is shown</param>
/// <param name="evt">The current mouse event, or <c>null</c>.</param>
/// <param name="entrySet">Entry set with the command definitions</param>
/// <param name="initialCommandTarget">Initial command target.</param>
public static bool ShowContextMenu(this Gtk.TreeView tree, Gdk.EventButton evt, Commands.CommandEntrySet entrySet,
object initialCommandTarget = null)
{
if (evt == null)
{
var paths = tree.Selection.GetSelectedRows();
if (paths != null)
{
var area = tree.GetCellArea(paths [0], tree.Columns [0]);
return(Ide.IdeApp.CommandService.ShowContextMenu(tree, area.Left, area.Top, entrySet, initialCommandTarget));
}
else
{
return(Ide.IdeApp.CommandService.ShowContextMenu(tree, 0, 0, entrySet, initialCommandTarget));
}
}
else
{
int x = (int)evt.X, y = (int)evt.Y;
if (Platform.IsMac && tree.BinWindow == evt.Window)
{
tree.ConvertBinWindowToWidgetCoords(x, y, out x, out y);
}
return(Ide.IdeApp.CommandService.ShowContextMenu(tree, x, y, entrySet, initialCommandTarget));
}
}
public void Initialize (IPadWindow window)
{
// Toolbar and menu definitions
ActionCommand gotoCmd = new ActionCommand (LocalCommands.GoToFile, GettextCatalog.GetString ("Go to File"));
ActionCommand propertiesCmd = new ActionCommand (LocalCommands.Properties, GettextCatalog.GetString ("Properties"), Gtk.Stock.Properties);
menuSet = new CommandEntrySet ();
menuSet.Add (gotoCmd);
menuSet.AddSeparator ();
menuSet.AddItem (DebugCommands.EnableDisableBreakpoint);
menuSet.AddItem (DebugCommands.ClearAllBreakpoints);
menuSet.AddItem (DebugCommands.DisableAllBreakpoints);
menuSet.AddItem (EditCommands.DeleteKey);
menuSet.AddSeparator ();
menuSet.Add (propertiesCmd);
CommandEntrySet toolbarSet = new CommandEntrySet ();
toolbarSet.AddItem (DebugCommands.EnableDisableBreakpoint);
toolbarSet.AddItem (DebugCommands.ClearAllBreakpoints);
toolbarSet.AddItem (DebugCommands.DisableAllBreakpoints);
toolbarSet.AddItem (EditCommands.Delete);
toolbarSet.AddSeparator ();
toolbarSet.Add (propertiesCmd);
// The breakpoint list
store = new TreeStore (typeof(string), typeof (bool), typeof(string), typeof(object), typeof(string), typeof(string), typeof(string), typeof(string));
tree = new PadTreeView ();
tree.Model = store;
tree.RulesHint = true;
tree.HeadersVisible = true;
tree.DoPopupMenu = ShowPopup;
tree.KeyPressEvent += OnKeyPressEvent;
treeState = new TreeViewState (tree, (int) Columns.Breakpoint);
TreeViewColumn col = new TreeViewColumn ();
CellRenderer crp = new CellRendererIcon ();
col.PackStart (crp, false);
col.AddAttribute (crp, "stock_id", (int) Columns.Icon);
tree.AppendColumn (col);
Gtk.CellRendererToggle toggleRender = new Gtk.CellRendererToggle ();
toggleRender.Toggled += new ToggledHandler (ItemToggled);
col = new TreeViewColumn ();
col.PackStart (toggleRender, false);
col.AddAttribute (toggleRender, "active", (int) Columns.Selected);
tree.AppendColumn (col);
TreeViewColumn FrameCol = new TreeViewColumn ();
CellRenderer crt = tree.TextRenderer;
FrameCol.Title = GettextCatalog.GetString ("Name");
FrameCol.PackStart (crt, true);
FrameCol.AddAttribute (crt, "text", (int) Columns.FileName);
FrameCol.Resizable = true;
FrameCol.Alignment = 0.0f;
tree.AppendColumn (FrameCol);
col = tree.AppendColumn (GettextCatalog.GetString ("Condition"), crt, "text", (int) Columns.Condition);
col.Resizable = true;
col = tree.AppendColumn (GettextCatalog.GetString ("Trace Expression"), crt, "text", (int) Columns.TraceExp);
col.Resizable = true;
col = tree.AppendColumn (GettextCatalog.GetString ("Hit Count"), crt, "text", (int) Columns.HitCount);
col.Resizable = true;
col = tree.AppendColumn (GettextCatalog.GetString ("Last Trace"), crt, "text", (int) Columns.LastTrace);
col.Resizable = true;
sw = new Gtk.ScrolledWindow ();
sw.ShadowType = ShadowType.None;
sw.Add (tree);
control = sw;
control.ShowAll ();
bps = DebuggingService.Breakpoints;
UpdateDisplay ();
breakpointUpdatedHandler = DispatchService.GuiDispatch<EventHandler<BreakpointEventArgs>> (OnBreakpointUpdated);
breakpointRemovedHandler = DispatchService.GuiDispatch<EventHandler<BreakpointEventArgs>> (OnBreakpointRemoved);
breakpointAddedHandler = DispatchService.GuiDispatch<EventHandler<BreakpointEventArgs>> (OnBreakpointAdded);
breakpointChangedHandler = DispatchService.GuiDispatch<EventHandler> (OnBreakpointChanged);
DebuggingService.Breakpoints.BreakpointAdded += breakpointAddedHandler;
DebuggingService.Breakpoints.BreakpointRemoved += breakpointRemovedHandler;
DebuggingService.Breakpoints.Changed += breakpointChangedHandler;
DebuggingService.Breakpoints.BreakpointUpdated += breakpointUpdatedHandler;
DebuggingService.PausedEvent += OnDebuggerStatusCheck;
DebuggingService.ResumedEvent += OnDebuggerStatusCheck;
DebuggingService.StoppedEvent += OnDebuggerStatusCheck;
tree.RowActivated += OnRowActivated;
DockItemToolbar toolbar = window.GetToolbar (PositionType.Top);
toolbar.Add (toolbarSet, sw);
toolbar.ShowAll ();
}
public void ShowContextMenu (CommandEntrySet entrySet, object initialTarget)
{
CommandMenu menu = (CommandMenu) CreateMenu (entrySet);
ShowContextMenu (menu, initialTarget);
}
public void ShowContextMenu (CommandEntrySet entrySet)
{
ShowContextMenu (entrySet, null);
}
public void InsertOptions (Gtk.Menu menu, CommandEntrySet entrySet, int index)
{
CommandTargetRoute route = new CommandTargetRoute ();
foreach (CommandEntry entry in entrySet) {
Gtk.MenuItem item = entry.CreateMenuItem (this);
CustomItem ci = item.Child as CustomItem;
if (ci != null)
ci.SetMenuStyle (menu);
int n = menu.Children.Length;
menu.Insert (item, index);
if (item is ICommandUserItem)
((ICommandUserItem)item).Update (route);
else
item.Show ();
index += menu.Children.Length - n;
}
}
void HandleInspectEditorButtonPressEvent (object o, ButtonPressEventArgs args)
{
if (args.Event.Button != 3)
return;
var menuSet = new CommandEntrySet ();
menuSet.AddItem (EditCommands.SelectAll);
menuSet.AddItem (EditCommands.Copy);
IdeApp.CommandService.ShowContextMenu (this, args.Event, menuSet, this);
}
/// <summary>
/// Creates a toolbar.
/// </summary>
/// <returns>
/// The toolbar.
/// </returns>
/// <param name='id'>
/// Identifier of the toolbar
/// </param>
/// <param name='entrySet'>
/// Entry with the command definitions
/// </param>
/// <param name='initialTarget'>
/// Initial command route target. The command handler will start looking for command handlers in this object.
/// </param>
public Gtk.Toolbar CreateToolbar (string id, CommandEntrySet entrySet, object initialTarget)
{
CommandToolbar toolbar = new CommandToolbar (this, id, entrySet.Name);
toolbar.InitialCommandTarget = initialTarget;
foreach (CommandEntry entry in entrySet) {
Gtk.ToolItem ti = entry.CreateToolItem (this);
CustomItem ci = ti.Child as CustomItem;
if (ci != null)
ci.SetToolbarStyle (toolbar);
toolbar.Add (ti);
}
ToolbarTracker tt = new ToolbarTracker ();
tt.Track (toolbar);
return toolbar;
}
/// <summary>
/// Creates a toolbar.
/// </summary>
/// <returns>
/// The toolbar.
/// </returns>
/// <param name='entrySet'>
/// Entry with the command definitions
/// </param>
/// <param name='initialTarget'>
/// Initial command route target. The command handler will start looking for command handlers in this object.
/// </param>
public Gtk.Toolbar CreateToolbar (CommandEntrySet entrySet, object initialTarget)
{
return CreateToolbar ("", entrySet, initialTarget);
}
/// <summary>
/// Shows a context menu.
/// </summary>
/// <param name='parent'>
/// Widget for which the context menu is being shown
/// </param>
/// <param name='evt'>
/// Current event
/// </param>
/// <param name='entrySet'>
/// Entry with the command definitions
/// </param>
/// <param name='initialCommandTarget'>
/// Initial command route target. The command handler will start looking for command handlers in this object.
/// </param>
public bool ShowContextMenu (Gtk.Widget parent, Gdk.EventButton evt, CommandEntrySet entrySet,
object initialCommandTarget = null)
{
if (Platform.IsMac) {
parent.GrabFocus ();
int x, y;
if (evt != null) {
x = (int)evt.X;
y = (int)evt.Y;
} else {
Gdk.Display.Default.GetPointer (out x, out y);
}
return DesktopService.ShowContextMenu (this, parent, x, y, entrySet, initialCommandTarget);
} else {
var menu = CreateMenu (entrySet);
if (menu != null)
ShowContextMenu (parent, evt, menu, initialCommandTarget);
return true;
}
}
/// <summary>
/// Creates a menu.
/// </summary>
/// <returns>
/// The menu.
/// </returns>
/// <param name='entrySet'>
/// Entry with the command definitions
/// </param>
public Gtk.Menu CreateMenu (CommandEntrySet entrySet)
{
return CreateMenu (entrySet, new CommandMenu (this));
}
public CommandMenu(CommandManager manager, CommandEntrySet commandEntrySet) : this(manager)
{
this.commandEntrySet = commandEntrySet;
}
/// <summary>
/// Creates the menu.
/// </summary>
/// <returns>
/// The menu.
/// </returns>
/// <param name='entrySet'>
/// Entry with the command definitions
/// </param>
/// <param name='initialTarget'>
/// Initial command route target. The command handler will start looking for command handlers in this object.
/// </param>
public Gtk.Menu CreateMenu (CommandEntrySet entrySet, object initialTarget)
{
var menu = (CommandMenu) CreateMenu (entrySet, new CommandMenu (this));
menu.InitialCommandTarget = initialTarget;
return menu;
}
public LogTextView (TextBuffer buf) : base (buf)
{
menuSet = new CommandEntrySet ();
SetupMenu ();
}
/// <summary>
/// Creates a toolbar.
/// </summary>
/// <returns>
/// The toolbar.
/// </returns>
/// <param name='entrySet'>
/// Entry with the command definitions
/// </param>
public Gtk.Toolbar CreateToolbar (CommandEntrySet entrySet)
{
return CreateToolbar ("", entrySet, null);
}
public LogTextView ()
{
menuSet = new CommandEntrySet ();
SetupMenu ();
}
/// <summary>
/// Creates a toolbar.
/// </summary>
/// <returns>
/// The toolbar.
/// </returns>
/// <param name='id'>
/// Identifier of the toolbar
/// </param>
/// <param name='entrySet'>
/// Entry with the command definitions
/// </param>
public Gtk.Toolbar CreateToolbar (string id, CommandEntrySet entrySet)
{
return CreateToolbar (id, entrySet, null);
}
public StackTracePad ()
{
this.ShadowType = ShadowType.None;
ActionCommand evalCmd = new ActionCommand ("StackTracePad.EvaluateMethodParams", GettextCatalog.GetString ("Evaluate Method Parameters"));
ActionCommand gotoCmd = new ActionCommand ("StackTracePad.ActivateFrame", GettextCatalog.GetString ("Activate Stack Frame"));
menuSet = new CommandEntrySet ();
menuSet.Add (evalCmd);
menuSet.Add (gotoCmd);
menuSet.AddSeparator ();
menuSet.AddItem (EditCommands.SelectAll);
menuSet.AddItem (EditCommands.Copy);
store = new ListStore (typeof (string), typeof (string), typeof (string), typeof (string), typeof (string), typeof (string), typeof (Pango.Style), typeof (object), typeof (bool));
tree = new PadTreeView (store);
tree.RulesHint = true;
tree.HeadersVisible = true;
tree.Selection.Mode = SelectionMode.Multiple;
tree.EnableSearch = true;
tree.SearchColumn = 1;
tree.ButtonPressEvent += HandleButtonPressEvent;
tree.DoPopupMenu = ShowPopup;
TreeViewColumn col = new TreeViewColumn ();
CellRenderer crp = new CellRendererIcon ();
col.PackStart (crp, false);
col.AddAttribute (crp, "stock_id", 0);
tree.AppendColumn (col);
TreeViewColumn FrameCol = new TreeViewColumn ();
FrameCol.Title = GettextCatalog.GetString ("Name");
refresh = new CellRendererIcon ();
refresh.Pixbuf = ImageService.GetPixbuf (Gtk.Stock.Refresh).ScaleSimple (12, 12, Gdk.InterpType.Hyper);
FrameCol.PackStart (refresh, false);
FrameCol.AddAttribute (refresh, "visible", 8);
FrameCol.PackStart (tree.TextRenderer, true);
FrameCol.AddAttribute (tree.TextRenderer, "text", 1);
FrameCol.AddAttribute (tree.TextRenderer, "foreground", 5);
FrameCol.AddAttribute (tree.TextRenderer, "style", 6);
FrameCol.Resizable = true;
FrameCol.Alignment = 0.0f;
tree.AppendColumn (FrameCol);
col = new TreeViewColumn ();
col.Title = GettextCatalog.GetString ("File");
col.PackStart (tree.TextRenderer, false);
col.AddAttribute (tree.TextRenderer, "text", 2);
col.AddAttribute (tree.TextRenderer, "foreground", 5);
tree.AppendColumn (col);
col = new TreeViewColumn ();
col.Title = GettextCatalog.GetString ("Language");
col.PackStart (tree.TextRenderer, false);
col.AddAttribute (tree.TextRenderer, "text", 3);
col.AddAttribute (tree.TextRenderer, "foreground", 5);
tree.AppendColumn (col);
col = new TreeViewColumn ();
col.Title = GettextCatalog.GetString ("Address");
col.PackStart (tree.TextRenderer, false);
col.AddAttribute (tree.TextRenderer, "text", 4);
col.AddAttribute (tree.TextRenderer, "foreground", 5);
tree.AppendColumn (col);
Add (tree);
ShowAll ();
current_backtrace = DebuggingService.CurrentCallStack;
UpdateDisplay ();
DebuggingService.CallStackChanged += (EventHandler) DispatchService.GuiDispatch (new EventHandler (OnClassStackChanged));
DebuggingService.CurrentFrameChanged += (EventHandler) DispatchService.GuiDispatch (new EventHandler (OnFrameChanged));
tree.RowActivated += OnRowActivated;
}
protected override bool OnButtonPressEvent (EventButton evnt)
{
if (evnt.Button == 3) {
CommandEntrySet opset = new CommandEntrySet ();
opset.AddItem (BlameCommands.ShowDiff);
opset.AddItem (BlameCommands.ShowLog);
opset.AddItem (Command.Separator);
opset.AddItem (BlameCommands.CopyRevision);
IdeApp.CommandService.ShowContextMenu (opset, this);
} else {
if (evnt.X < leftSpacer) {
grabTime = evnt.Time;
var status = Gdk.Pointer.Grab (this.GdkWindow, false, EventMask.PointerMotionHintMask | EventMask.Button1MotionMask | EventMask.ButtonReleaseMask | EventMask.EnterNotifyMask | EventMask.LeaveNotifyMask, null, null, grabTime);
if (status == GrabStatus.Success) {
dragPosition = evnt.X;
}
}
}
return base.OnButtonPressEvent (evnt);
}
void DoPopupMenu (Gdk.EventButton evnt)
{
object commandChain = this;
CommandEntrySet opset = new CommandEntrySet ();
VersionControlItemList items = GetSelectedItems ();
foreach (object ob in AddinManager.GetExtensionNodes ("/MonoDevelop/VersionControl/StatusViewCommands")) {
if (ob is TypeExtensionNode) {
TypeExtensionNode node = (TypeExtensionNode) ob;
opset.AddItem (ParseCommandId (node));
VersionControlCommandHandler handler = node.CreateInstance () as VersionControlCommandHandler;
if (handler == null) {
LoggingService.LogError ("Invalid type specified in extension point 'MonoDevelop/VersionControl/StatusViewCommands'. Subclass of 'VersionControlCommandHandler' expected.");
continue;
}
handler.Init (items);
CommandRouter rt = new CommandRouter (handler);
rt.Next = commandChain;
commandChain = rt;
} else
opset.AddSeparator ();
}
IdeApp.CommandService.ShowContextMenu (filelist, evnt, opset, commandChain);