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