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);