def enable(self):
self.glade = gtk.glade.XML(get_resource("config.glade"))
#component.get("Preferences").add_page("BatchRenamerRegEx", self.glade.get_widget("batch_prefs"))
# add the MenuItem to the context menu.
torrentmenu = component.get("MenuBar").torrentmenu
self.menu_item = gtk.ImageMenuItem("Rename Files")
img = gtk.image_new_from_stock(gtk.STOCK_CONVERT, gtk.ICON_SIZE_MENU)
self.menu_item.set_image(img)
self.menu_item.connect("activate", self.rename_selected_torrent)
torrentmenu.append(self.menu_item)
torrentmenu.show_all()
def button_press(self, widget, event):
if event.button == 3:
menu = gtk.Menu()
item = gtk.ImageMenuItem(_('Save As...'))
img = gtk.Image()
img.set_from_stock('tryton-save-as', gtk.ICON_SIZE_MENU)
item.set_image(img)
item.connect('activate', self.save)
item.show()
menu.append(item)
menu.popup(None, None, None, event.button, event.time)
return True
elif event.button == 1:
self.widgets['root'].action()
def make_menu(self, widget, menu):
leave_fullscreen = gtk.STOCK_LEAVE_FULLSCREEN
self.surfingnow = gtk.ImageMenuItem("Página de inicio")
self.snimage = gtk.Image()
self.snimage.set_from_stock(gtk.STOCK_HOME, gtk.ICON_SIZE_MENU)
self.surfingnow.set_image(self.snimage)
self.surfingnow.connect("activate", self.go_home_cb, None)
menu.append(self.surfingnow)
self.surfingnow.show()
self.fullscreen = gtk.ImageMenuItem("Pantalla completa")
self.fsimage = gtk.Image()
self.fsimage.set_from_stock(gtk.STOCK_FULLSCREEN, gtk.ICON_SIZE_MENU)
self.fullscreen.set_image(self.fsimage)
self.fullscreen.connect("activate", self.goto_fullscreen, None)
menu.append(self.fullscreen)
self.fullscreen.show()
self.lfullscreen = gtk.ImageMenuItem("Salir de pantalla completa")
self.lfsimage = gtk.Image()
self.lfsimage.set_from_stock(leave_fullscreen, gtk.ICON_SIZE_MENU)
self.lfullscreen.set_image(self.lfsimage)
self.lfullscreen.connect("activate", self.leave_fullscreen, None)
menu.append(self.lfullscreen)
self.lfullscreen.show()
def on_PHOTO_eventbox_button_press_event(self, widget, event):
'''If right-clicked, show popup'''
if event.button == 3: # right click
menu = gtk.Menu()
menuitem = gtk.ImageMenuItem(gtk.STOCK_SAVE_AS)
menuitem.connect(
'activate', gtkgui_helpers.on_avatar_save_as_menuitem_activate,
self.contact.jid, self.account,
self.contact.get_shown_name() + '.jpeg')
menu.append(menuitem)
menu.connect('selection-done', lambda w: w.destroy())
# show the menu
menu.show_all()
menu.popup(None, None, None, event.button, event.time)
def menu_item(self,detach_func=None,attach_func=None,\
detach_text=None,attach_text=None):
#Applet wants a Detach applet menu icon
if self['detached'] == False:
menu = gtk.ImageMenuItem(gtk.STOCK_GO_UP)
menu.get_children()[0].set_text(\
[detach_text,'Detach'][detach_text is None])
if detach_func is not None:
menu.connect('activate', detach_func)
#Applet wants an Attach applet menu icon
else:
menu = gtk.ImageMenuItem(gtk.STOCK_GO_DOWN)
menu.get_children()[0].set_text(\
[attach_text,'Attach'][attach_text is None])
if attach_func is not None:
menu.connect('activate', attach_func)
return menu
def do_bookmarks_popup_menu(self, button, event):
'''Handler for button-release-event, triggers popup menu for bookmarks.'''
if event.button != 3:
return False
path = button.zim_path
_button_width = button.size_request()[0]
direction = 'left' if (int(event.x) <= _button_width / 2) else 'right'
def set_save_bookmark(path):
self._saved_bookmark = path
if button.get_label() in (path, self._get_short_page_name(path)):
rename_button_text = _('Set New Name') # T: button label
else:
rename_button_text = _('Back to Original Name') # T: button label
# main popup menu
main_menu = gtk.Menu()
main_menu_items = (
(_('Remove'), lambda o: self.delete(path)), # T: menu item
(_('Remove All'), lambda o: self.delete_all(True)), # T: menu item
('separator', ''),
(_('Open in New Window'),
lambda o: self.ui.open_new_window(Path(path))), # T: menu item
('separator', ''),
('gtk-copy', lambda o: set_save_bookmark(path)),
('gtk-paste', lambda o: self.move_bookmark(self._saved_bookmark,
path, direction)),
('separator', ''),
(rename_button_text, lambda o: self.rename_bookmark(button)),
('separator', ''),
(_('Set to Current Page'), lambda o: self.change_bookmark(path))
) # T: menu item
for name, func in main_menu_items:
if name == 'separator':
item = gtk.SeparatorMenuItem()
else:
if 'gtk-' in name:
item = gtk.ImageMenuItem(name)
else:
item = gtk.MenuItem(name)
item.connect('activate', func)
main_menu.append(item)
main_menu.show_all()
main_menu.popup(None, None, None, 3, 0)
return True
def add_imi(self, stock, name, title):
"""
@param stock:
@param name:
@param title:
@return:
"""
item = gtk.ImageMenuItem(stock)
item.set_name(name)
item.set_label(title)
item.set_always_show_image(True)
item.connect('activate', self.activated)
self.append(item)
return item
def __init__ (self, todo_dict):
self.ind = appindicator.Indicator("todo-menu", "indicator-messages", appindicator.CATEGORY_APPLICATION_STATUS)
self.ind.set_status(appindicator.STATUS_ACTIVE)
self.ind.set_attention_icon ("indicator-messages-new")
self.ind.set_icon("distributor-logo")
# Main menu
self.menu = gtk.Menu()
# Sort the todo list items according to their proirity
sorted_keys = sort_keys(todo_dict)
sorted_values = []
for key in sorted_keys:
sorted_values.append(todo_dict[key][0])
# Add the values in sorted_values list to the manu
# As a gtk.CheckMenuItem
for i in range(len(sorted_values)):
check = gtk.CheckMenuItem( sorted_values[i] )
check.set_active(False)
if todo_dict[ sorted_keys[i] ][1]:
check.set_active(True)
else:
check.set_active(False)
check.connect("activate", self.mark_done, sorted_keys[i])
check.show()
# Check whether the task is already read or not and hence toggle the tick-mark
# The read status is the second element in the tuple which is the value in the todo_dict
self.menu.append(check)
sep = gtk.SeparatorMenuItem()
sep.show()
self.menu.append(sep)
select_item = gtk.MenuItem("Select the todo.txt file...")
select_item.connect("activate", self.change_filename)
select_item.show()
self.menu.append(select_item)
quit = gtk.ImageMenuItem(gtk.STOCK_QUIT)
quit.connect("activate", self.quit)
quit.show()
self.menu.append(quit)
self.menu.show()
self.ind.set_menu(self.menu)
def __append_contact(self, contact):
"""
appends a contact to our submenu
"""
item = gtk.ImageMenuItem()
item.set_label(gui.Plus.msnplus_strip(contact.nick))
pict = self.__get_contact_pixbuf_or_default(contact.picture)
item.set_image(pict)
item.connect('activate', self._on_contact_clicked)
self.item_to_contacts[item] = contact
self.contacts_to_item[contact.account] = item
item.show()
self.add(item)
def populate_popup(self, view, menu):
"""Create a popup menu for the scroll lock and clear functions"""
menu.append(gtk.SeparatorMenuItem())
lock = gtk.CheckMenuItem("Scroll Lock")
menu.append(lock)
lock.set_active(self.scroll_lock)
lock.connect('activate', self.scroll_back_cb, view)
clear = gtk.ImageMenuItem(gtk.STOCK_CLEAR)
menu.append(clear)
clear.connect('activate', self.clear_cb, view)
menu.show_all()
return False
def button(text, action, icon=None):
if icon == 'check':
item = gtk.CheckMenuItem(text)
item.set_active(True)
elif icon:
item = gtk.ImageMenuItem(text)
item.set_image(
gtk.image_new_from_stock(icon, gtk.ICON_SIZE_MENU))
else:
item = gtk.MenuItem(text)
item.connect('activate', action)
item.show()
menu.append(item)
return item
def newImageMenuItem(self, label, stock=None, img=None, animation=None):
mi = gtk.ImageMenuItem(label)
if stock != None:
mi.set_image(gtk.image_new_from_stock(stock, gtk.ICON_SIZE_MENU))
elif img != None:
image = gtk.Image()
image.set_from_pixbuf(img)
mi.set_image(image)
elif animation != None:
image = gtk.Image()
image.set_from_animation(animation)
mi.set_image(image)
return mi
def __init__(self):
gtk.MenuBar.__init__(self)
# build the file menu
file_menu = gtk.Menu()
file_menu_item = gtk.ImageMenuItem(_('_File'))
file_menu_item.set_submenu(file_menu)
open_menu_item = gtk.ImageMenuItem(gtk.STOCK_OPEN)
file_menu.add(open_menu_item)
clear_menu_item = gtk.ImageMenuItem(gtk.STOCK_CLEAR)
file_menu.add(clear_menu_item)
file_menu.add(gtk.SeparatorMenuItem())
quit_menu_item = gtk.ImageMenuItem(gtk.STOCK_QUIT)
file_menu.add(quit_menu_item)
open_menu_item.connect("activate" , self.on_open_activate)
clear_menu_item.connect("activate" , self.on_clear_activate)
quit_menu_item.connect("activate" , self.on_quit_activate)
self.add(file_menu_item)
file_menu.show_all()
def __init__(self, handler, main_window=None):
"""
constructor
handler -- a e3common.Handler.TrayIconHandler object
"""
gtk.Menu.__init__(self)
self.handler = handler
StatusMenu = extension.get_default('menu status')
self.status = gtk.ImageMenuItem(_('Status'))
self.status.set_image(gtk.image_new_from_stock(gtk.STOCK_CONVERT,
gtk.ICON_SIZE_MENU))
self.status_menu = StatusMenu(handler.on_status_selected)
self.status.set_submenu(self.status_menu)
self.list = gtk.MenuItem(_('Contacts'))
self.list_contacts = ContactsMenu(handler, main_window)
self.list.set_submenu(self.list_contacts)
self.hide_show_mainwindow = gtk.MenuItem(_('Hide/Show emesene'))
self.hide_show_mainwindow.connect('activate',
lambda *args: self.handler.on_hide_show_mainwindow(main_window))
self.disconnect = gtk.ImageMenuItem(gtk.STOCK_DISCONNECT)
self.disconnect.connect('activate',
lambda *args: self.handler.on_disconnect_selected())
self.quit = gtk.ImageMenuItem(gtk.STOCK_QUIT)
self.quit.connect('activate',
lambda *args: self.handler.on_quit_selected())
self.append(self.hide_show_mainwindow)
self.append(self.status)
self.append(self.list)
self.append(self.disconnect)
self.append(gtk.SeparatorMenuItem())
self.append(self.quit)
def callback(self, menuitems, menu, terminal):
"""Add our menu items to the menu"""
item = gtk.MenuItem(_('_Custom Commands'))
menuitems.append(item)
submenu = gtk.Menu()
item.set_submenu(submenu)
menuitem = gtk.ImageMenuItem(_('_Preferences'))
menuitem.connect("activate", self.configure)
submenu.append(menuitem)
menuitem = gtk.SeparatorMenuItem()
submenu.append(menuitem)
theme = gtk.icon_theme_get_default()
for command in [
self.cmd_list[key] for key in sorted(self.cmd_list.keys())
]:
if not command['enabled']:
continue
exe = command['command'].split(' ')[0]
iconinfo = theme.choose_icon([exe], gtk.ICON_SIZE_MENU,
gtk.ICON_LOOKUP_USE_BUILTIN)
if iconinfo:
image = gtk.Image()
image.set_from_icon_name(exe, gtk.ICON_SIZE_MENU)
menuitem = gtk.ImageMenuItem(command['name'])
menuitem.set_image(image)
else:
menuitem = gtk.MenuItem(command["name"])
terminals = terminal.terminator.get_target_terms(terminal)
menuitem.connect("activate", self._execute, {
'terminals': terminals,
'command': command['command']
})
submenu.append(menuitem)
def __init__(self, session, members):
'''constructor'''
gtk.HBox.__init__(self)
self.set_border_width(2)
SmileyLabel = extension.get_default('smiley label')
self._information = SmileyLabel()
eventBox = gtk.EventBox()
eventBox.set_visible_window(False)
eventBox.add(self._information)
eventBox.connect('button-press-event', self.on_clicked)
self.pack_start(eventBox, True, True)
self.session = session
self.members = members
self.menu = gtk.Menu()
copynick = gtk.ImageMenuItem(_('Copy nick'))
copynick.set_image(
utils.safe_gtk_image_load(gui.theme.image_theme.user))
copypm = gtk.ImageMenuItem(_('Copy personal message'))
copypm.set_image(
gtk.image_new_from_stock(gtk.STOCK_DIALOG_INFO,
gtk.ICON_SIZE_MENU))
copymail = gtk.ImageMenuItem(_('Copy mail'))
copymail.set_image(
utils.safe_gtk_image_load(gui.theme.image_theme.email))
self.menu.append(copynick)
self.menu.append(copypm)
self.menu.append(copymail)
copynick.connect('activate', self.copy_nick)
copypm.connect('activate', self.copy_pm)
copymail.connect('activate', self.copy_mail)
copynick.show()
copypm.show()
copymail.show()
def __init__(self, session, members):
'''constructor'''
gtk.HBox.__init__(self)
self.set_border_width(2)
self._information = gtk.Label('info')
self._information.set_ellipsize(pango.ELLIPSIZE_END)
self._information.set_alignment(0.0, 0.5)
self.eventBox = gtk.EventBox()
self.eventBox.set_visible_window(False)
self.eventBox.add(self._information)
self.eventBox.connect('button-press-event', self.on_clicked)
self.pack_start(self.eventBox, True, True)
self.session = session
self.members = members
self.menu = gtk.Menu()
copynick = gtk.ImageMenuItem('Copy nick to clipboard')
copynick.set_image(
gtk.image_new_from_stock(gtk.STOCK_COPY, gtk.ICON_SIZE_MENU))
copypm = gtk.ImageMenuItem('Copy personal message to clipboard')
copypm.set_image(
gtk.image_new_from_stock(gtk.STOCK_COPY, gtk.ICON_SIZE_MENU))
copymail = gtk.ImageMenuItem('Copy mail to clipboard')
copymail.set_image(
gtk.image_new_from_stock(gtk.STOCK_COPY, gtk.ICON_SIZE_MENU))
self.menu.append(copynick)
self.menu.append(copypm)
self.menu.append(copymail)
copynick.connect('activate', self.copy_nick)
copypm.connect('activate', self.copy_pm)
copymail.connect('activate', self.copy_mail)
copynick.show()
copypm.show()
copymail.show()
def _make_folder_menu(self, folder):
if folder != self._bookmarks.get_top_parent():
menu = gtk.Menu()
else:
menu = self
menuitem = None
for element in self._bookmarks.get_element_list_sorted(folder):
element_name = self._bookmarks.get_element_name(element)
if element_name == u'folder':
menuitem = gtk.ImageMenuItem('gtk-directory')
submenu = self._make_folder_menu(element)
glib.idle_add(self._add_add_items, element, submenu)
menuitem.set_submenu(submenu)
menuitem.connect('button-press-event',
self._folder_press, element)
elif element_name == u'bookmark':
icon = gtk.Image()
icon.set_from_icon_name('text-html', gtk.ICON_SIZE_MENU)
menuitem = gtk.ImageMenuItem('text-html')
menuitem.set_image(icon)
menuitem.set_tooltip_text(self._bookmarks.get_uri(element))
menuitem.connect('drag-data-get', self._get_bookmark_data, element)
menuitem.connect('drag-begin', lambda i, *a: i.set_data('drag', True)) #self._bookmark_drag_begin)
menuitem.connect('drag-end', lambda i, *a: i.set_data('drag', False)) #self._bookmark_drag_end)
menuitem.drag_source_set(gtk.gdk.BUTTON1_MASK,
[("text/plain", 0, 0)], gtk.gdk.ACTION_COPY)
menuitem.connect('button-release-event',
self._bookmark_release, element)
if menuitem:
menuitem.set_label(self._bookmarks.get_title_text(element))
label = menuitem.get_children()[0]
label.set_max_width_chars(48)
label.set_ellipsize(pango.ELLIPSIZE_END)
glib.idle_add(menuitem.show_all)
glib.idle_add(menu.add, menuitem)
menuitem = None
return menu
def menu_from_list(alist):
while alist and not alist[-1]:
alist.pop(-1)
last = None
for item in alist:
if item != last:
if item:
if len(item) == 2:
name, function = item
menuitem = gtk.ImageMenuItem(name)
elif len(item) == 3:
name, stock_id, function = item
if isinstance(stock_id, bool):
menuitem = gtk.CheckMenuItem(name)
menuitem.set_active(stock_id)
else:
menuitem = gtk.ImageMenuItem(stock_id)
if isinstance(function, list):
submenu = gtk.Menu()
for subitem in menu_from_list(function):
submenu.append(subitem)
menuitem.set_submenu(submenu)
else:
menuitem.connect("activate", lambda a, f: f(), function)
yield menuitem
else:
yield gtk.SeparatorMenuItem()
last = item
def _update_popup_menu(self, tbutton, menu, keyword):
for item in menu.get_children():
if (getattr(item, '_update_action', False)
or isinstance(item, gtk.SeparatorMenuItem)):
menu.remove(item)
buttons = [b for b in self.screen.get_buttons()
if keyword == b.attrs.get('keyword', 'action')]
if buttons and menu.get_children():
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)
kw_plugins = []
for plugin in plugins.MODULES:
for plugin_spec in plugin.get_plugins(self.model):
name, func = plugin_spec[:2]
try:
plugin_keyword = plugin_spec[2]
except IndexError:
plugin_keyword = 'action'
if keyword != plugin_keyword:
continue
kw_plugins.append((name, func))
if kw_plugins:
menu.add(gtk.SeparatorMenuItem())
for name, func in kw_plugins:
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 __volume_mounted_cb(self,
device_manager,
uid,
human_name,
volume_type,
data=None):
menu_item = gtk.ImageMenuItem(human_name)
if self.icon_theme.has_icon(self.stock_icons[volume_type]):
icon = gtk.image_new_from_icon_name(self.stock_icons[volume_type],
gtk.ICON_SIZE_MENU)
menu_item.set_image(icon)
menu_item.show()
self.menu.prepend(menu_item)
self.no_devices_menu_item.hide()
self.sicon.set_from_icon_name("harddrive")
self.sicon.set_visible(True)
# Signal
menu_item.connect("activate", self.__device_activate_cb, uid)
self.menu_volumes.append({
"uid": uid,
"menu_item": menu_item,
})
if self.conf.get_show_notify_detected():
if self.__is_hermes_running() == False:
if volume_type != "cdrom":
msg = _(
"Remember umount it when you finish your work if you wan't to lose your information"
)
else:
msg = ""
self.show_notification(
_("New device detected\n<small>(%s)</small>") % human_name,
msg, self.stock_icons[volume_type])
else:
self.sicon.set_blinking(True)
gobject.timeout_add(5000, self.__timeout_remove_blink_cb)
if self.conf.get_blink_all_time():
self.sicon.set_blinking(True)
# Restart timeout
gobject.source_remove(self.timeout_id)
miliseconds = self.conf.get_minutes_warning() * 60 * 1000
self.timeout_id = gobject.timeout_add(miliseconds, self.__timeout_cb)
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("autocollapse")
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("Menu Demo")
self.set_default_size(500, 450)
self.set_position(gtk.WIN_POS_CENTER)
mb = gtk.MenuBar()
menu1 = gtk.Menu()
file = gtk.MenuItem("_File")
file.set_submenu(menu1)
acgroup = gtk.AccelGroup()
self.add_accel_group(acgroup)
new = gtk.ImageMenuItem(gtk.STOCK_NEW, acgroup)
new.add_accelerator("activate", acgroup, ord('N'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
menu1.append(new)
open = gtk.ImageMenuItem(gtk.STOCK_OPEN)
menu1.append(open)
chk = gtk.CheckMenuItem("Checkable")
menu1.append(chk)
radio1 = gtk.RadioMenuItem(None, "Radio1")
radio2 = gtk.RadioMenuItem(radio1, "Radio2")
menu1.append(radio1)
menu1.append(radio2)
sep = gtk.SeparatorMenuItem()
menu1.append(sep)
exit = gtk.ImageMenuItem(gtk.STOCK_QUIT)
menu1.append(exit)
menu2 = gtk.Menu()
edit = gtk.MenuItem("_Edit")
edit.set_submenu(menu2)
copy = gtk.ImageMenuItem(gtk.STOCK_COPY)
menu2.append(copy)
cut = gtk.ImageMenuItem(gtk.STOCK_CUT)
menu2.append(cut)
paste = gtk.ImageMenuItem(gtk.STOCK_PASTE)
menu2.append(paste)
mb.append(file)
mb.append(edit)
vbox = gtk.VBox(False, 2)
vbox.pack_start(mb, False, False, 0)
self.add(vbox)
self.connect("destroy", gtk.main_quit)
self.show_all()
def create_menu(self, index=None):
self.popupMenu = gtk.Menu()
if index:
#~ menuPopup = gtk.MenuItem(self.launcher[index]['name'])
#~ self.popupMenu.add(menuPopup)
## Edit this widget
menuPopup = gtk.ImageMenuItem(gtk.STOCK_EDIT)
menuPopup.connect("activate", self.edit_widget, index)
self.popupMenu.add(menuPopup)
## Edit preferences
menuPopup = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES)
menuPopup.connect("activate", self.edit_config)
self.popupMenu.add(menuPopup)
if self.cfg['show_quit']:
## Quit
menuPopup = gtk.ImageMenuItem(gtk.STOCK_QUIT)
menuPopup.connect("activate", self.doquit)
self.popupMenu.add(menuPopup)
self.popupMenu.show_all()
def __init__(self, handler):
"""
constructor
handler -- a e3common.Handler.TrayIconHandler object
"""
gtk.Menu.__init__(self)
self.handler = handler
self.hide_show_mainwindow = gtk.MenuItem('Hide/Show emesene')
self.quit = gtk.ImageMenuItem(gtk.STOCK_QUIT)
self.quit.connect('activate',
lambda *args: self.handler.on_quit_selected())
self.append(self.hide_show_mainwindow)
self.append(self.quit)
def __add_remove_breakpoint_item(self, menu, breakpoints):
assert len(breakpoints)
item = gtk.ImageMenuItem("todo")
item.get_child().set_label("Remove Breakpoint")
menu.append(item)
if len(breakpoints) == 1:
b = breakpoints[0]
item.connect("activate", self.__remove_breakpoint, b)
else:
subMenu = gtk.Menu()
item.set_submenu(subMenu)
for b in breakpoints:
subItem = gtk.MenuItem(hex(b.addr()))
subMenu.append(subItem)
subItem.connect("activate", self.__remove_breakpoint, b)
def __add_set_breakpoint_item(self, menu, label, thread, breakpoints):
item = gtk.ImageMenuItem("gtk-dialog-error")
item.get_child().set_label(label)
menu.append(item)
if len(breakpoints) > 1:
subMenu = gtk.Menu()
item.set_submenu(subMenu)
for a in breakpoints:
print "__add_set_breakpoint_item", hex(a)
subItem = gtk.MenuItem(hex(a))
subMenu.append(subItem)
subItem.connect("activate", self.__set_breakpoint, thread, a)
elif len(breakpoints):
a = breakpoints[0]
item.connect("activate", self.__set_breakpoint, thread, a)
def pop_up(self, iconview, event):
''' manage the context menu (?) '''
if event.button == 3 and self.label.get_text() != 'System pictures':
path = self.iconview.get_path_at_pos(event.x, event.y)
if path != None:
self.iconview.select_path(path)
remove_menu = gtk.Menu()
remove_item = gtk.ImageMenuItem('Delete')
remove_item.set_image(
gtk.image_new_from_stock(gtk.STOCK_REMOVE,
gtk.ICON_SIZE_MENU))
remove_item.connect('activate', self.chooser.on_remove)
remove_menu.append(remove_item)
remove_menu.popup(None, None, None, event.button, event.time)
remove_menu.show_all()
def popup(self, statusicon, button, activate_time):
pop_menu = gtk.Menu()
for i in SSH:
_item = gtk.ImageMenuItem(gtk.STOCK_CONNECT)
_item.set_name(i)
_item.set_label(i)
_item.connect("activate", self.do_ssh)
pop_menu.append(_item)
for i in RDESKTOP:
_item = gtk.ImageMenuItem(gtk.STOCK_NETWORK)
_item.set_name(i)
_item.set_label(re.sub(r'-p[^ ]+', '-p***', i))
_item.connect("activate", self.do_rdesktop)
pop_menu.append(_item)
pop_menu.append(gtk.SeparatorMenuItem())
_item = gtk.ImageMenuItem(gtk.STOCK_EDIT)
_item.set_label('Edit')
_item.connect("activate", self.edit_self)
pop_menu.append(_item)
_item = gtk.ImageMenuItem(gtk.STOCK_REFRESH)
_item.set_label('Restart')
_item.connect("activate", self.restart)
pop_menu.append(_item)
_item = gtk.ImageMenuItem(gtk.STOCK_QUIT)
_item.set_label('Quit')
_item.connect("activate", gtk.main_quit)
pop_menu.append(_item)
pop_menu.show_all()
pop_menu.popup(None, None, None, 0, gtk.get_current_event_time())
def init_menu(self):
self.slider = gtk.HScale()
self.slider.set_can_focus(False)
self.slider.set_size_request(VOLUME_WIDTH,
VOLUME_HEIGHT)
self.slider.set_range(0, 100)
self.slider.set_digits(0)
self.slider.set_draw_value(True)
self.slider.connect('value-changed', self.on_slide)
slider_item = gtk.ImageMenuItem()
slider_item.add(self.slider)
self.redirect_events(slider_item, self.slider)
reload_button = gtk.Button(RELOAD_MIXER_LABEL)
reload_button.set_focus_on_click(False)
reload_button.connect('button-release-event',
self.reload_mixer)
reload_mixer_item = gtk.ImageMenuItem()
reload_mixer_item.add(reload_button)
self.redirect_events(reload_mixer_item, reload_button)
mixer_item = gtk.MenuItem(MIXER_LABEL)
mixer_item.connect('activate', self.activate_mixer)
exit_item = gtk.MenuItem(EXIT_LABEL)
exit_item.connect('activate', self._exit)
self.menu = gtk.Menu()
self.menu.append(slider_item)
self.menu.append(reload_mixer_item)
self.menu.append(mixer_item)
self.menu.append(exit_item)
self.menu.connect('show', self.on_menu_show)
self.menu.connect('hide', self.on_menu_hide)
self.menu.show_all()
