def _menu_open(self, obj, event): if event.button == 3: menu = gtk.Menu() for stock_id, callback, sensitivity in self._menu_entries: if stock_id: item = gtk.ImageMenuItem(stock_id) if callback: item.connect("activate", callback) item.set_sensitive(sensitivity) else: item = gtk.SeparatorMenuItem() item.show() menu.append(item) menu.popup(None, None, None, event.button, event.time) return True
def __create_context_menu(self): # build and connect the popup menu menu = gtk.Menu() menuItem = gtk.ImageMenuItem(_("Check for new episodes")) menuItem.set_image(gtk.image_new_from_stock(gtk.STOCK_FIND, gtk.ICON_SIZE_MENU)) menuItem.connect('activate', self.__gpodder.on_itemUpdate_activate) menu.append(menuItem) menuItem = gtk.ImageMenuItem(_("Download all new episodes")) menuItem.set_image(gtk.image_new_from_stock(gtk.STOCK_GO_DOWN, gtk.ICON_SIZE_MENU)) menuItem.connect('activate', self.__gpodder.on_itemDownloadAllNew_activate) menu.append(menuItem) # menus's label will adapt to the synchronisation device name if self._config.device_type != 'none': menuItem = gtk.ImageMenuItem(_('Synchronize to device')) menuItem.set_sensitive(self._config.device_type != 'none') menuItem.set_image(gtk.image_new_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_MENU)) menuItem.connect('activate', self.__gpodder.on_sync_to_ipod_activate) menu.append(menuItem) menu.append( gtk.SeparatorMenuItem()) menuItem = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES) menuItem.connect('activate', self.__gpodder.on_itemPreferences_activate) menu.append(menuItem) menuItem = gtk.ImageMenuItem(gtk.STOCK_ABOUT) menuItem.connect('activate', self.__gpodder.on_itemAbout_activate) menu.append(menuItem) menu.append( gtk.SeparatorMenuItem()) menuItem = gtk.ImageMenuItem(gtk.STOCK_QUIT) menuItem.connect('activate', self.__on_exit_callback) menu.append(menuItem) return menu
def _fill_menu(self, actions, menu=None): """Create a menu from list of actions""" menu = menu or gtk.Menu() for item in actions: if isinstance(item, tuple): menu_item = self._make_sub_menu(*item) elif isinstance(item, str): menu_item = getattr(self, 'create_' + item)() elif item is None: menu_item = gtk.SeparatorMenuItem() else: menu_item = item.create_menu_item() menu.append(menu_item) menu.show_all() return menu
def RightClick(self, a_oEvent): t_oMenu = gtk.Menu() t_oMenuItem = gtk.MenuItem("Show Image") t_oMenuItem.connect("activate", self.ShowBlockGUI) t_oMenu.append(t_oMenuItem) t_oMenuItem = gtk.MenuItem("PrintXML") t_oMenuItem.connect("activate", self.PrintXML) t_oMenu.append(t_oMenuItem) t_oMenuItem = gtk.SeparatorMenuItem() t_oMenu.append(t_oMenuItem) t_oMenuItem = gtk.MenuItem("Delete") t_oMenuItem.connect("activate", self.DeleteClicked) t_oMenu.append(t_oMenuItem) t_oMenuItem = gtk.SeparatorMenuItem() t_oMenu.append(t_oMenuItem) # Shows the menu t_oMenu.show_all() t_oMenu.popup(None, None, None, a_oEvent.button, a_oEvent.time)
def _update_action_popup(self, tbutton, menu): for item in menu.get_children(): if (getattr(item, '_update_action', False) or isinstance(item, gtk.SeparatorMenuItem)): menu.remove(item) buttons = self.screen.get_buttons() if buttons: menu.add(gtk.SeparatorMenuItem()) for button in buttons: menuitem = gtk.ImageMenuItem() menuitem.set_label('_' + button.attrs.get('string', _('Unknown'))) menuitem.set_use_underline(True) if button.attrs.get('icon'): icon = gtk.Image() icon.set_from_stock(button.attrs['icon'], gtk.ICON_SIZE_MENU) menuitem.set_image(icon) menuitem.connect('activate', lambda m, attrs: self.screen.button(attrs), button.attrs) menuitem._update_action = True menu.add(menuitem) menu.add(gtk.SeparatorMenuItem()) for plugin in plugins.MODULES: for name, func in plugin.get_plugins(self.model): menuitem = gtk.MenuItem('_' + name) menuitem.set_use_underline(True) menuitem.connect('activate', lambda m, func: func({ 'model': self.model, 'ids': [r.id for r in self.screen.selected_records], 'id': (self.screen.current_record.id if self.screen.current_record else None), }), func) menuitem._update_action = True menu.add(menuitem)
def control_menu_items(menu_obj): separator = gtk.SeparatorMenuItem() menu_obj.append(separator) separator.show() show_notifications_menuitem = gtk.CheckMenuItem("Show notifications") show_notifications_menuitem.set_active(show_notifications) show_notifications_menuitem.connect('toggled', switch_show_notifications) menu_obj.append(show_notifications_menuitem) show_notifications_menuitem.show() quit_item = gtk.MenuItem("Exit") quit_item.connect('activate', gtk.main_quit) menu_obj.append(quit_item) quit_item.show()
def __init__(self): self.menu_items = [] self.menu_items.append((gtk.ImageMenuItem("Start bridging"), self.on_menu_start)) self.menu_items.append((gtk.ImageMenuItem("Stop bridging"), self.on_menu_stop)) self.menu_items.append((gtk.SeparatorMenuItem(), None)) self.menu_items.append((gtk.ImageMenuItem("Reactivate"), self.on_menu_reactivate)) self.menu_items.append((gtk.ImageMenuItem("Quit"), self.on_menu_destroy)) self.menu = gtk.Menu() for menu_tuple in self.menu_items: item, callback = menu_tuple self.menu.append(item) if callback: item.connect("activate", callback) self.menu.show_all()
def calculate_popup_menu(self): popup_menu = gtk.Menu() menu_items = self.make_popup_menu_items() if self.menu_items != menu_items: for label, callback in menu_items: if not label and not callback: item = gtk.SeparatorMenuItem() else: item = gtk.ImageMenuItem(label) item.connect('activate', callback) popup_menu.append(item) popup_menu.show_all() self.indicator.set_menu(popup_menu) self.menu_items = menu_items
def __init__(self, data_path=None, parent=None): super(gtk.Menu, self).__init__() self.windowmain = parent edit_record = gtk.ImageMenuItem(gtk.STOCK_EDIT) edit_record.set_label(_("Edit Record")) edit_record.connect("activate", self.on_editrecord_activate) self.attach(edit_record, 0, 1, 0, 1) show_graph = gtk.ImageMenuItem(gtk.STOCK_FIND) show_graph.set_label(_("Show graph in classic view")) show_graph.connect("activate", self.on_showclassic_activate) self.attach(show_graph, 0, 1, 1, 2) self.attach(gtk.SeparatorMenuItem(), 0, 1, 2, 3) remove_record = gtk.ImageMenuItem(gtk.STOCK_DELETE) remove_record.connect("activate", self.on_remove_activate) self.attach(remove_record, 0, 1, 3, 4)
def new(self): self.title_updated() self.cover_downloader.register('cover-available', \ self.cover_download_finished) self.cover_downloader.request_cover(self.channel) b = self.textview.get_buffer() b.set_text(self.channel.description) b.place_cursor(b.get_start_iter()) self.main_window.show() menu = gtk.Menu() menu.append(self.action_rename.create_menu_item()) menu.append(self.action_authentication.create_menu_item()) menu.append(gtk.SeparatorMenuItem()) menu.append(self.action_refresh_cover.create_menu_item()) menu.append(self.action_custom_cover.create_menu_item()) menu.append(gtk.SeparatorMenuItem()) menu.append(self.action_visit_website.create_menu_item()) menu.append(gtk.SeparatorMenuItem()) menu.append(self.action_close.create_menu_item()) self.main_window.set_menu(self.set_finger_friendly(menu)) self.main_window.connect('key-press-event', self._on_key_press_event)
def enable(self): self.files_tab = component.get('TorrentDetails').tabs['Files'] log.debug('mediainfo: creating menu items') self.file_menu = self.files_tab.file_menu self.media_info_separator = gtk.SeparatorMenuItem() self.media_info_button = gtk.MenuItem(_('MediaInfo')) self.file_menu.append(self.media_info_separator) self.media_info_separator.show() self.media_info_button.connect('activate', self._on_media_info_activate) self.file_menu.append(self.media_info_button) self.media_info_button.show() log.debug('mediainfo: connecting handler') self.connector_id = self.file_menu.connect('show', self.on_popup_show)
def __call__(self): """ Create menu for udiskie mount operations. :returns: a new menu :rtype: gtk.Menu """ # create actions items menu = self._branchmenu(self._prepare_menu(self.detect()).groups) # append menu item for closing the application if self._actions.get('quit'): if len(menu) > 0: menu.append(gtk.SeparatorMenuItem()) menu.append(self._actionitem('quit')) return menu
def build_related(submenu, el): """Build the related annotations submenu for the given element. """ if submenu.get_children(): # The submenu was already populated. return False if el.incomingRelations: i = gtk.MenuItem(_("Incoming")) submenu.append(i) i = gtk.SeparatorMenuItem() submenu.append(i) for t, l in el.typedRelatedIn.iteritems(): at = self.controller.package.get_element_by_id(t) m = gtk.MenuItem(self.get_title(at), use_underline=False) amenu = gtk.Menu() m.set_submenu(amenu) amenu.connect('map', build_submenu, at, l) submenu.append(m) if submenu.get_children(): # There were incoming annotations. Use a separator i = gtk.SeparatorMenuItem() submenu.append(i) if el.outgoingRelations: i = gtk.MenuItem(_("Outgoing")) submenu.append(i) i = gtk.SeparatorMenuItem() submenu.append(i) for t, l in el.typedRelatedOut.iteritems(): at = self.controller.package.get_element_by_id(t) m = gtk.MenuItem(self.get_title(at), use_underline=False) amenu = gtk.Menu() m.set_submenu(amenu) amenu.connect('map', build_submenu, at, l) submenu.append(m) submenu.show_all() return False
def setup_context_menu(self): """Add "Edit Menus" to the context menu. """ menu = self.applet.dialog.menu menu_index = len(menu) - 1 edit_menus_item = gtk.MenuItem(_("_Edit Menus")) edit_menus_item.connect("activate", self.show_menu_editor_cb) edit_menus_item.show_all() menu.insert(edit_menus_item, menu_index) separator_item = gtk.SeparatorMenuItem() separator_item.show_all() menu.insert(separator_item, menu_index + 1)
def on_populate_popup(self, textview, popup): cfg = self.app.config sep = gtk.SeparatorMenuItem() sep.show() popup.append(sep) item = gtk.CheckMenuItem(_(u"Split statements")) item.set_active(cfg.get("sqlparse.enabled")) item.connect("toggled", lambda x: cfg.set("sqlparse.enabled", x.get_active())) item.show() popup.append(item) item = gtk.ImageMenuItem("gtk-close") item.show() item.connect("activate", self.on_close) popup.append(item)
def add_items(self, items): for i in items.keys(): menuVertical = gtk.Menu() fileitem = gtk.MenuItem(i) fileitem.set_submenu(menuVertical) subItems = items[i] for sItem in sorted(subItems.keys()): if (sItem == ""): subItem = gtk.SeparatorMenuItem() else: subItem = gtk.MenuItem(sItem) subItem.connect("activate", subItems[sItem]) menuVertical.append(subItem) self.append(fileitem)
def _on_create_menu_proxy(self, toolitem): # create the overflow menu m = gtk.MenuItem(' ') menu = gtk.Menu() for c in self.get_menu().get_children(): action = c.get_action() if action is not None: mi = action.create_menu_item() else: mi = gtk.SeparatorMenuItem() menu.append(mi) m.set_submenu(menu) m.show_all() self.set_proxy_menu_item("gtk-tool-button-menu-id", m) return True
def __init__(self, dock, conn_manager, conn_zone): # Call parent constructor SystrayBase.__init__(self, dock, conn_manager, conn_zone) # Instantiate a AppIndicator self.__indicator = appindicator.Indicator( 'tgcm-%s' % tgcm.country_support, '__indicator-messages', appindicator.CATEGORY_APPLICATION_STATUS) self.__indicator.set_status(appindicator.STATUS_ACTIVE) self.__indicator.set_property('title', self._config.get_app_name()) # Get the location of the icons icon_theme_path = os.path.dirname(self._theme_manager.get_icon('icons', 'conectado.png')) self.__indicator.set_icon_theme_path(icon_theme_path) ### Glade menu modifications ### # Substitute the current open entry with a new with a checkbutton self.open.hide() self.open_item = gtk.CheckMenuItem(_('Show the dock')) self.open_item.set_active(self._config.get_ui_general_key_value('systray_showing_mw')) self.open_item.show() self.menu.insert(self.open_item, 0) # Add a menu separator item = gtk.SeparatorMenuItem() item.show() self.menu.insert(item, 1) # Create menu entries about connection status, statistics, etc. self.__labels = {} labels = ['connection', 'speed', 'time', 'data_usage', 'sms'] i = 2 for label in labels: item = SystrayIndicator.IndicatorLabelEntry() item.set_text(label) self.menu.insert(item.get_item(), i) self.__labels[label] = item i += 1 # Load the gtk.Menu object into AppIndicator self.__indicator.set_menu(self.menu) # Prepare the labels self.__update_labels() # Connect various signals self._connect_signals()
def __init__(self): self.TopBar = gtk.MenuBar() FileList = gtk.Menu() FileFold = gtk.MenuItem('_Plik') FileFold = gtk.ImageMenuItem(gtk.STOCK_OPEN) FilePosSeparator = gtk.SeparatorMenuItem() FilePos_Quit = gtk.ImageMenuItem(gtk.STOCK_QUIT) FilePos_Quit.connect('activate', MemberFunctions.FilePos_Quit) FileList.append(FilePosSeparator) FileList.append(FilePos_Quit) ToolsList = gtk.Menu() ToolsFold = gtk.MenuItem('_Narzedzia') ToolsPos_AddKata = gtk.MenuItem('_Dodaj katalog') ToolsPos_AddKata.connect('activate', MemberFunctions.ToolsPos_AddKata) ToolsPos_AddLink = gtk.MenuItem('_Dodaj link') ToolsPos_AddLink.connect('activate', MemberFunctions.ToolsPos_AddLink) ToolsPos_AddHttp = gtk.MenuItem('_Dodaj http') ToolsPos_AddHttp.connect('activate', MemberFunctions.ToolsPos_AddHttp) ToolsPos_DelePosi = gtk.MenuItem('_Usun pozycje') ToolsPos_DelePosi.connect('activate', MemberFunctions.ToolsPos_DelePosi) ToolsPos_ChangName = gtk.MenuItem('_Zmien nazwe katalogu') ToolsPos_ChangName.connect('activate', MemberFunctions.ToolsPos_ChangName) ToolsPos_ChangNameTab = gtk.MenuItem('_Zmien nazwe zakladki') ToolsPos_ChangNameTab.connect('activate', MemberFunctions.ToolsPos_ChangNameTab) ToolsPos_Help = gtk.MenuItem('_Pomoc') ToolsPos_Help.connect('activate', MemberFunctions.ToolsPos_Help) ToolsList.append(ToolsPos_AddKata) ToolsList.append(ToolsPos_AddLink) ToolsList.append(ToolsPos_AddHttp) ToolsList.append(ToolsPos_DelePosi) ToolsList.append(ToolsPos_ChangName) ToolsList.append(ToolsPos_ChangNameTab) ToolsList.append(ToolsPos_Help) FileFold.set_submenu(FileList) ToolsFold.set_submenu(ToolsList) self.TopBar.append(FileFold) self.TopBar.append(ToolsFold) return
def update_folder_menu(self, folder): """ Updates the submenu for the given folder with the current size and updates each peer. """ folderitem = self.folderitems[folder['name']] folderitem['sizeitem'].set_label(folder['size']) menu = folderitem['menuitem'].get_submenu() curfolder = [ f for f in self.status['folders'] if folder['name'] == f['name'] ].pop() curpeernames = [ peer['name'] for peer in curfolder['peers'] ] newpeernames = [ peer['name'] for peer in folder['peers'] ] updatepeers = [ peer for peer in folder['peers'] if peer['name'] in curpeernames ] newpeers = [ peer for peer in folder['peers'] if peer['name'] not in curpeernames ] oldpeers = [ peer for peer in curfolder['peers'] if peer['name'] not in newpeernames ] for peer in newpeers: bottomseppos = menu.get_children().index(folderitem['bottomsepitem']) buf = self.format_status(peer) peeritem = gtk.MenuItem(buf) peeritem.set_sensitive(False) peeritem.show() folderitem['peeritems'][peer['name']] = peeritem pos = bottomseppos if (folderitem['topsepitem'] == None): sep = gtk.SeparatorMenuItem() sep.show() menu.insert(sep, pos) folderitem['topsepitem'] = sep pos = pos+1 menu.insert(peeritem, pos) for peer in updatepeers: buf = self.format_status(peer) folderitem['peeritems'][peer['name']].set_label(buf) for peer in oldpeers: menu.remove(folderitem['peeritems'][peer['name']]) topseppos = menu.get_children().index(folderitem['topsepitem']) bottomseppos = menu.get_children().index(folderitem['bottomsepitem']) if (topseppos == bottomseppos-1): menu.remove(folderitem['topsepitem']) folderitem['topsepitem'] = None
def setup_menu(self): """ Setup the tray menu Adds action menu items and task placeholders, which are later replaced with real recently modified tasks (see set_tasks). """ self.menu = gtk.Menu() def add_item(label, handler, icon=None): if icon is None: item = gtk.MenuItem() else: item = gtk.ImageMenuItem(icon) item.set_label(label) item.connect("activate", handler) item.show() self.menu.append(item) return item self.task_items = [] for x in range(10): item = gtk.ImageMenuItem() item.set_label("task placeholder") item.connect("activate", lambda item: self.on_task_selected(item.get_data("task"))) self.menu.append(item) self.task_items.append(item) self.separator = gtk.SeparatorMenuItem() self.menu.append(self.separator) add_item("Add new task...", lambda *args: self.on_add_task(), gtk.STOCK_NEW) add_item("Search tasks...", lambda *args: self.on_toggle(), gtk.STOCK_FIND) self.stop_item = add_item("Stop all running tasks", lambda *args: self.on_stop_all(), gtk.STOCK_STOP) if self.can_pull(): add_item("Pull tasks", lambda *args: self.on_pull(), gtk.STOCK_REFRESH) add_item("Quit", lambda *args: self.on_quit(), gtk.STOCK_QUIT)
def create_toplevel_ws(self, width, height, group, x=None, y=None): # create top level workspace root = gtk.Window(gtk.WINDOW_TOPLEVEL) ## root.set_title(title) # TODO: this needs to be more sophisticated root.set_border_width(2) root.set_default_size(width, height) root.show() #self.update_pending() vbox = gtk.VBox() root.add(vbox) menubar = gtk.MenuBar() vbox.pack_start(menubar, fill=True, expand=False) # create a Window pulldown menu, and add it to the menu bar winmenu = gtk.Menu() item = gtk.MenuItem(label="Window") menubar.append(item) item.show() item.set_submenu(winmenu) ## w = gtk.MenuItem("Take Tab") ## winmenu.append(w) #w.connect("activate", lambda w: self.gui_take_tab()) sep = gtk.SeparatorMenuItem() winmenu.append(sep) quit_item = gtk.MenuItem(label="Close") winmenu.append(quit_item) #quit_item.connect_object ("activate", self.quit, "file.exit") quit_item.show() bnch = self.make_ws(group=group) vbox.pack_start(bnch.widget, padding=2, fill=True, expand=True) root.connect("delete_event", lambda w, e: self.close_page_cb(bnch, root)) lbl = gtk.Statusbar() lbl.set_has_resize_grip(True) vbox.pack_end(lbl, expand=False, fill=True, padding=2) vbox.show_all() root.show_all() if x != None: win = root.get_window() win.move(x, y) return bnch
def _popup_view_menu(self, widget, event): # Create a menu below the widget for view options. menu = gtk.Menu() meta_menuitem = gtk.CheckMenuItem(label="Show expanded value info") if len(self.column_names) == len(self._visible_metadata_columns): meta_menuitem.set_active(True) meta_menuitem.connect("toggled", self._toggle_show_more_info) meta_menuitem.show() if not self.stash_meta_lookup: meta_menuitem.set_sensitive(False) menu.append(meta_menuitem) col_title_menuitem = gtk.CheckMenuItem( label="Show expanded column titles") if self._should_show_meta_column_titles: col_title_menuitem.set_active(True) col_title_menuitem.connect("toggled", self._toggle_show_meta_column_titles) col_title_menuitem.show() if not self.stash_meta_lookup: col_title_menuitem.set_sensitive(False) menu.append(col_title_menuitem) sep = gtk.SeparatorMenuItem() sep.show() menu.append(sep) show_column_menuitem = gtk.MenuItem("Show/hide columns") show_column_menuitem.show() show_column_menu = gtk.Menu() show_column_menuitem.set_submenu(show_column_menu) menu.append(show_column_menuitem) for i, column in enumerate(self._view.get_columns()): col_name = self.column_names[i] col_title = col_name.replace("_", "__") if self._should_show_meta_column_titles: col_meta = self.stash_meta_lookup.get(col_name, {}) title = col_meta.get(rose.META_PROP_TITLE) if title is not None: col_title = title col_menuitem = gtk.CheckMenuItem(label=col_title, use_underline=False) col_menuitem.show() col_menuitem.set_active(column.get_visible()) col_menuitem._connect_args = (col_name, ) col_menuitem.connect( "toggled", lambda c: self._toggle_show_column_name(*c._connect_args)) show_column_menu.append(col_menuitem) menu.popup(None, None, widget.position_menu, event.button, event.time, widget)
def popup_menu(bev, obj, model, path, cache_explorer): menu = gtk.Menu() for i in obj.menu_items: if i is None: item = gtk.SeparatorMenuItem() else: name, cb = i item = gtk.MenuItem(name) def _cb(item, cb=cb): action_required = cb(obj, cache_explorer) if action_required is ACTION_REMOVE: model.remove(model.get_iter(path)) item.connect('activate', _cb) item.show() menu.append(item) menu.popup(None, None, None, bev.button, bev.time)
def populate_popup(self, view, menu): menu.append(gtk.SeparatorMenuItem()) i = gtk.ImageMenuItem(gtk.STOCK_ZOOM_IN) i.connect('activate', lambda m, v, *a, **k: v.zoom_in(), view) menu.append(i) i = gtk.ImageMenuItem(gtk.STOCK_ZOOM_OUT) i.connect('activate', lambda m, v, **k: v.zoom_out(), view) menu.append(i) i = gtk.ImageMenuItem(gtk.STOCK_ZOOM_100) i.connect( 'activate', lambda m, v, *a, **k: v.get_zoom_level() == 1.0 or v. set_zoom_level(1.0), view) menu.append(i) menu.show_all() return False
def on_openwith_for_file(self, action): menuitem = action.get_proxies()[0] menuitem.remove_submenu() menu = gtk.Menu() menuitem.set_submenu(menu) file_name = action.contexts_kw['file_name'] for item in self.svc.get_items_for_file(file_name): act = gtk.Action(item.name, item.name, item.command, gtk.STOCK_EXECUTE) act.connect('activate', self.on_open_with, file_name, item) mi = act.create_menu_item() menu.append(mi) menu.append(gtk.SeparatorMenuItem()) act = self.svc.get_action('show_openwith') menu.append(act.create_menu_item()) menu.show_all()
def add_items(self, parent, items): for item in items: if item is None: parent.append(gtk.SeparatorMenuItem()) elif type(item)is types.TupleType: action = self.actions[item[0]] menuitem = gtk.CheckMenuItem(action.tooltip) action.connect_proxy(menuitem) action.menuitem = menuitem menuitem.set_active(False) parent.append(menuitem) else: action = self.actions[item] menuitem = action.create_menu_item() action.menuitem = menuitem parent.append(menuitem)
def __set_menu_main(self,title,submenu=None): m_item=gtk.MenuItem(title) if submenu!=None: menu=gtk.Menu() for l in submenu: if l=='-': item=gtk.SeparatorMenuItem() else: if len(l)!=2: item=gtk.MenuItem(l) else: item=gtk.MenuItem(l[0]) item.connect_object("activate",self.__on_click,l[1],l[1]) menu.append(item) m_item.set_submenu(menu) return m_item
def __onClick(self, treeview, event): if event.button == 2: if options.singleton().jumpToTagOnMiddleClick: x, y = int(event.x), int(event.y) pthinfo = treeview.get_path_at_pos(x, y) if pthinfo is None: return path, col, cellx, celly = pthinfo self.__jump_to_tag(path) return True if event.button == 3: x, y = int(event.x), int(event.y) pthinfo = treeview.get_path_at_pos(x, y) if pthinfo is None: return path, col, cellx, celly = pthinfo #treeview.grab_focus() #treeview.set_cursor(path) menu = gtk.Menu() tagpos = self.parser.get_tag_position(self.browser.get_model(),path) if tagpos is not None: filename, line = tagpos m = gtk.ImageMenuItem(gtk.STOCK_JUMP_TO) menu.append(m) m.show() m.connect("activate", lambda w,p,l: self.__openDocumentAtLine(p,l), filename, line ) # add the menu items from the parser menuitems = self.parser.get_menu(self.browser.get_model(),path) for item in menuitems: menu.append(item) item.show() m = gtk.SeparatorMenuItem() m.show() menu.append( m ) m = gtk.CheckMenuItem("Auto-_collapse") menu.append(m) m.show() m.set_active( options.singleton().autocollapse ) def setcollapse(w): options.singleton().autocollapse = w.get_active() m.connect("toggled", setcollapse ) menu.popup( None, None, None, event.button, event.time)
def __init__(self): super(PyApp, self).__init__() self.set_title("Image menu") self.set_size_request(250, 200) self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(6400, 6400, 6400)) self.set_position(gtk.WIN_POS_CENTER) mb = gtk.MenuBar() filemenu = gtk.Menu() filem = gtk.MenuItem("_File") filem.set_submenu(filemenu) agr = gtk.AccelGroup() self.add_accel_group(agr) newi = gtk.ImageMenuItem(gtk.STOCK_NEW, agr) key, mod = gtk.accelerator_parse("<Control>N") newi.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE) filemenu.append(newi) openm = gtk.ImageMenuItem(gtk.STOCK_OPEN, agr) key, mod = gtk.accelerator_parse("<Control>O") openm.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE) filemenu.append(openm) sep = gtk.SeparatorMenuItem() filemenu.append(sep) exit = gtk.ImageMenuItem(gtk.STOCK_QUIT, agr) key, mod = gtk.accelerator_parse("<Control>Q") exit.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE) exit.connect("activate", gtk.main_quit) filemenu.append(exit) mb.append(filem) vbox = gtk.VBox(False, 2) vbox.pack_start(mb, False, False, 0) self.add(vbox) self.connect("destroy", gtk.main_quit) self.show_all()