def setup_menu(self,indicator):
def add_item(item):
item.show()
menu.append(item)
return item
menu = gtk.Menu()
toggle_button = add_item(gtk.CheckMenuItem("Lock Orentation"))
toggle_button.connect("toggled", self.toggle, indicator)
indicator.set_secondary_activate_target(toggle_button)
add_item(gtk.SeparatorMenuItem())
palm_toggle_button = add_item(gtk.CheckMenuItem("Palm Rejection"))
palm_toggle_button.connect('toggled', self.palm_toggle, indicator)
palm_toggle_button.set_active(True)
add_item(gtk.MenuItem('About')).connect("activate", self.open_about_page)
add_item(gtk.MenuItem("Exit")).connect("activate", self.quit)
return menu
python类MenuItem()的实例源码
def build_menu(self):
menu = Gtk.Menu()
item_unlock = Gtk.MenuItem('Unlock')
item_unlock.connect('activate', self.unlock)
menu.append(item_unlock)
self.item_unlock = item_unlock
self.item_unlock.set_sensitive(False) # default state
item_help = Gtk.MenuItem('Help')
item_help.connect('activate', self.open_help)
menu.append(item_help)
separator = Gtk.SeparatorMenuItem()
menu.append(separator)
item_quit = Gtk.MenuItem('Quit')
item_quit.connect('activate', self.quit)
menu.append(item_quit)
menu.show_all()
return menu
def build_login_menu(self):
def open_login(context):
webbrowser.open(self.cfg_cls.LOGIN_URI, new=1, autoraise=True)
login_menu = Gtk.Menu()
item_login = Gtk.MenuItem('Login')
item_separator = Gtk.SeparatorMenuItem()
item_quit = Gtk.MenuItem('Quit')
item_login.connect('activate', open_login)
item_quit.connect('activate', self.quit)
login_menu.append(item_login)
login_menu.append(item_separator)
login_menu.append(item_quit)
login_menu.show_all()
self.INDICATOR.set_menu(login_menu)
def _create_menu(self):
menu = Gtk.Menu()
self._menu_item = Gtk.MenuItem("Bitcoin")
self._menu_item.connect('activate', self._on_show_item_activate)
menu.append(self._menu_item)
options_menu_item = Gtk.MenuItem("Options...")
options_menu_item.connect('activate', self._on_options_item_activate)
menu.append(options_menu_item)
alarm_menu_item = Gtk.MenuItem("Alarms...")
alarm_menu_item.connect('activate', self._on_alarm_item_activate)
menu.append(alarm_menu_item)
quit_menu_item = Gtk.MenuItem("Quit")
quit_menu_item.connect('activate', Gtk.main_quit)
menu.append(quit_menu_item)
menu.show_all()
return menu
def build_menu(menu):
item_status = gtk.MenuItem('Status')
#item_status.connect('activate', status)
menu.append(item_status)
item_status.set_sensitive(False)
item_backup = gtk.MenuItem('Backup')
item_backup.connect('activate', backup)
menu.append(item_backup)
item_gotobackup = gtk.MenuItem('Open remote backup folder')
item_gotobackup.connect('activate', gotobackup)
menu.append(item_gotobackup)
item_quit = gtk.MenuItem('Quit')
item_quit.connect('activate', quit)
menu.append(item_quit)
menu.show_all()
return menu
def build_menu(self):
menu = gtk.Menu()
item_status = gtk.MenuItem('Connect')
item_status.connect('activate', self.connect)
menu.append(item_status)
item_status = gtk.MenuItem('Disconnect')
item_status.connect('activate', self.disconnect)
menu.append(item_status)
item_status = gtk.MenuItem('Display Connection Status')
item_status.connect('activate', self.get_status)
menu.append(item_status)
item_quit = gtk.MenuItem('Quit')
item_quit.connect('activate', self.quit)
menu.append(item_quit)
menu.show_all()
return menu
def create_quarter_menu(self):
quarter_menu = Gtk.Menu()
for key in self.quarters:
quarter_item = Gtk.MenuItem()
button = Gtk.CheckButton.new_with_label(self.quarters[key])
if not self.hidden[key*2]:
button.set_active(True)
quarter_key = key*2
quarter_item.connect('activate', self.toggle_quarter, quarter_key)
quarter_item.add(button)
quarter_menu.append(quarter_item)
quarter_menu.show_all()
return quarter_menu
def make_menu(self, event_button, event_time):
menu = gtk.Menu()
# show about dialog
about = gtk.MenuItem("About")
about.show()
menu.append(about)
about.connect('activate', self.show_about_dialog)
# add quit item
quit = gtk.MenuItem("Quit")
quit.show()
menu.append(quit)
quit.connect('activate', gtk.main_quit)
menu.popup(None, None, None, None, event_button, event_time)
def __init__(self):
Gtk.ScrolledWindow.__init__(self)
self.view = Gtk.IconView()
self.list = Gtk.ListStore(Pixbuf, str)
self.view.set_model(self.list)
self.view.set_pixbuf_column(0)
self.view.set_text_column(1)
self.view.set_activate_on_single_click(True)
self.view.set_item_width(100)
self.menu = Gtk.Menu()
copy = Gtk.MenuItem('Copy')
copy.connect('activate', self.copy)
paste = Gtk.MenuItem('Paste')
paste.connect('activate', self.paste)
self.menu.append(copy)
self.menu.append(paste)
self.view.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self.view.connect('button-press-event', self.show_menu)
self.view.set_vexpand(True)
self.view.set_hexpand(True)
self.add(self.view)
self.view.connect('item-activated', self.row_activated)
def load_servers(self):
for child in self.server_submenu.get_children():
self.server_submenu.remove(child)
servers = self.config.get('configs', '[]')
index = self.config.get('index', 0)
group = []
i = 0
for server in servers:
name = server['remarks'] + '(' + server['server'] + ':' + str(server['port']) + ')'
item = Gtk.RadioMenuItem.new_with_label(group, name)
item.connect('activate', self.server_activate, server, i)
self.server_submenu.append(item)
group = item.get_group()
if i == index:
item.set_active(True)
self.server_activate(item, server, i)
i = i + 1
self.server_submenu.append(Gtk.SeparatorMenuItem())
self.open_server_item = Gtk.MenuItem('???????...')
self.open_server_item.connect('activate', self.show_server_setting)
self.server_submenu.append(self.open_server_item)
self.server_submenu.show_all()
def on_treeview_button_release_event(self,widget,event):
try:
#define context menu
popup=Gtk.Menu()
kd_item=Gtk.MenuItem(_("Open with Kdenlive"))
#selected row is already caught by on_treeview_selection_changed function
kd_item.connect("activate",self.on_open_with_kdenlive,self.sel_folder)
#don't show menu item if there are no video files
if self.sel_vid > 0 and cli.kd_supp is True:
popup.append(kd_item)
open_item=Gtk.MenuItem(_("Open folder"))
open_item.connect("activate",self.on_open_folder,self.sel_folder)
popup.append(open_item)
popup.show_all()
#only show on right click
if event.button == 3:
popup.popup(None,None,None,None,event.button,event.time)
return True
except AttributeError:
# this error (missing variable self.sel_folder) is returned when clicking on title row
# ignoring because there is nothing to happen on right click
return
def main():
global indicator, menu
indicator = appindicator.Indicator.new(APPINDICATOR_ID, os.path.abspath('closed.svg'), appindicator.IndicatorCategory.SYSTEM_SERVICES)
indicator.set_status(appindicator.IndicatorStatus.ACTIVE)
pubnub = set_up_pubnub()
menu = gtk.Menu()
item = gtk.MenuItem('Quit')
item.connect('activate', die, pubnub)
menu.append(item)
menu.show_all()
indicator.set_menu(menu)
indicator.set_icon(os.path.abspath("closed.svg"))
notify.init(APPINDICATOR_ID)
GObject.timeout_add_seconds(1, check_caps, pubnub)
gtk.main()
def build_menu():
menu = gtk.Menu()
### item ###
item_on = gtk.MenuItem('On') # menu label
item_on.connect('activate', keyboard_on) #actions
menu.append(item_on) #add menu
### item ###
item_off = gtk.MenuItem('Off') # menu label
item_off.connect('activate', keyboard_off) #actions
menu.append(item_off) #add menu
### item ###
item_quit = gtk.MenuItem('Quit') # menu label
item_quit.connect('activate', quit) #actions
menu.append(item_quit) #add menu
menu.show_all()
return menu
### execute binary script ###
def __init__(self, listbox, dialog):
""" pass in list box to manage and connect event """
self.logs = LogWindow()
self.listbox = listbox
self.listbox.connect('row-activated', self.listbox_row_activated)
self.menu = Gtk.Menu()
menu_item0 = Gtk.MenuItem("Terminal")
menu_item0.connect('button_press_event', self.open_terminal)
self.menu.append(menu_item0)
menu_item1 = Gtk.MenuItem("Show Logs")
self.menu.append(menu_item1)
menu_item1.connect('button_press_event', self.show_loged)
menu_item2 = Gtk.MenuItem("Test")
self.menu.append(menu_item2)
self.confirm_dialog = dialog
def build_menu(self):
menu = gtk.Menu()
item = gtk.MenuItem('Battery monitor')
item.connect('activate', self.battery_monitor)
menu.append(item)
item = gtk.MenuItem('Toggle theme')
item.connect('activate', self.toggle_theme)
menu.append(item)
item = gtk.MenuItem('Quit')
item.connect('activate', self.quit)
menu.append(item)
menu.show_all()
return menu
def create_menu(self):
menu = Gtk.Menu()
# NBA results items
for game in self.nba_games:
item = Gtk.MenuItem(game['score'])
item.connect('activate', self.on_click, game['gameinfo_url'])
menu.append(item)
# Quit item
item_quit = Gtk.MenuItem('Quit')
item_quit.connect('activate', self.on_quit)
menu.append(item_quit)
menu.show_all()
self.indicator.set_menu(menu)
def __init__(self, indicator_id='myappindicator'):
self.APPINDICATOR_ID = indicator_id
self.indicator = appindicator.Indicator.new( self.APPINDICATOR_ID, 'whatever', appindicator.IndicatorCategory.SYSTEM_SERVICES)
self.indicator.set_status(appindicator.IndicatorStatus.ACTIVE)
# Set Menu
menu = gtk.Menu()
item_quit = gtk.MenuItem('Quit')
item_quit.connect('activate', self.quit)
menu.show_all()
self.indicator.set_menu( menu )
self.update_server_status_icon()
signal.signal( signal.SIGINT, signal.SIG_DFL )
gtk.main()
def get_menu(self):
"""Create and populate the menu."""
menu = Gtk.Menu()
self.pomodoro_start = Gtk.MenuItem.new_with_label(_('Start'))
self.pomodoro_start.connect('activate', self.on_pomodoro_start)
self.pomodoro_start.show()
menu.append(self.pomodoro_start)
self.pomodoro_restart = Gtk.MenuItem.new_with_label(_('Re-start'))
self.pomodoro_restart.connect('activate', self.on_pomodoro_restart)
self.pomodoro_restart.show()
menu.append(self.pomodoro_restart)
separator1 = Gtk.SeparatorMenuItem()
separator1.show()
menu.append(separator1)
#
menu_preferences = Gtk.MenuItem.new_with_label(_('Preferences'))
menu_preferences.connect('activate', self.on_preferences_item)
menu_preferences.show()
menu.append(menu_preferences)
menu_help = Gtk.MenuItem.new_with_label(_('Help'))
menu_help.set_submenu(self.get_help_menu())
menu_help.show()
menu.append(menu_help)
#
separator2 = Gtk.SeparatorMenuItem()
separator2.show()
menu.append(separator2)
#
menu_exit = Gtk.MenuItem.new_with_label(_('Exit'))
menu_exit.connect('activate', self.on_quit_item)
menu_exit.show()
menu.append(menu_exit)
#
menu.show()
return(menu)
def create_menu(self):
message = Gtk.MenuItem('Starting up...')
self.menu.append(message)
self.menu.show_all()
self.popup = self.menu
self.appbutton.connect('clicked', self.popup_menu)
def edit_menu(self):
for i in self.menu.get_children():
self.menu.remove(i)
for m in self.newmenu:
add = Gtk.MenuItem(m)
add.connect('activate', self.get_choice)
self.menu.append(add)
# fake separator
self.menu.append(Gtk.MenuItem(''))
newspace = Gtk.MenuItem('+')
newspace.connect('activate', self.add_space)
self.menu.append(newspace)
self.change_onthefly()
self.menu.show_all()
def edit_menu2(self):
for i in self.menu.get_children():
self.menu.remove(i)
for m in self.newmenu:
ws = str(m[0] + 1)
space = Gtk.MenuItem(ws)
self.menu.append(space)
if m[1]:
# flattened submenu
self.submenu = Gtk.Menu()
for l in [d for d in m[1]]:
app = l[0]
wins = [[it[0], it[1]] for it in l[1]]
for w in wins:
name = self.shortname(w[0]) + " - " + app
winmention = Gtk.MenuItem(name)
self.submenu.append(winmention)
winmention.connect('activate', self.move_to, w[1])
space.set_submenu(self.submenu)
else:
space.connect('activate', self.get_choice)
# fake separator
self.menu.append(Gtk.MenuItem(''))
newspace = Gtk.MenuItem('+')
newspace.connect('activate', self.add_space)
self.menu.append(newspace)
self.change_onthefly()
self.menu.show_all()
def change_onthefly(self):
modesep = Gtk.SeparatorMenuItem()
self.menu.add(modesep)
mode_mention = Gtk.MenuItem("Mode")
applet_modes = Gtk.Menu()
active = modes.index(self.mode)
self.mode_index = active
self.menulist = [" " + m for m in modes]
self.menulist[active] = "? " + str(modes[active]) + ""
for item in self.menulist:
md = Gtk.MenuItem(item)
md.connect('activate', self.set_mode, item)
applet_modes.append(md)
mode_mention.set_submenu(applet_modes)
self.menu.add(mode_mention)
def __init__(self, callback):
Gtk.Menu.__init__(self)
for idx, pname in enumerate(soundcard.percussion_names):
menuitem = Gtk.MenuItem(pname)
menuitem.connect('activate', callback, idx)
self.append(menuitem)
menuitem.show()
self.show()
def popup_alsa_connection_list(self, widget):
connection_list = soundcard.alsa_sequencer.get_connection_list()
if connection_list:
menu = Gtk.Menu()
for clientid, portid, clientname, portname, labeltext in connection_list:
item = Gtk.MenuItem(labeltext)
menu.append(item)
def ff(widget, clientid, portid):
self.g_alsa_device.set_label(widget.get_child().get_text())
self.m_gui_client_port = (clientid, portid)
self.g_alsa_radio.set_active(True)
item.connect('activate', ff, clientid, portid)
menu.show_all()
menu.popup(None, None, None, None, 0, Gtk.get_current_event_time())
def _menu_hide_stuff(self, menu):
"""
Hide the menu if it has no menu items, or all menu items are hidden.
"""
for sub in menu.get_children():
assert isinstance(sub, Gtk.MenuItem)
if sub.get_submenu():
self._menu_hide_stuff(sub.get_submenu())
if not [c for c in sub.get_submenu().get_children() if c.get_property('visible')]:
sub.hide()
def __init__(self, callback):
Gtk.Menu.__init__(self)
self.m_callback = callback
for x in range(len(soundcard.instrument_names)):
if x % 8 == 0:
menuitem = Gtk.MenuItem(soundcard.instrument_sections[x/8])
submenu = Gtk.Menu()
self.append(menuitem)
menuitem.set_submenu(submenu)
menuitem.show()
item = Gtk.MenuItem(soundcard.instrument_names[x])
item.connect('activate', self.on_activate, x)
submenu.append(item)
item.show()
self.show()
def menu():
m = Gtk.Menu()
item_quit = Gtk.MenuItem('Quit')
item_quit.connect('activate', Gtk.main_quit)
m.append(item_quit)
m.show_all()
return m
def __create_playlist_menus(self):
for child in self.menuchild_gridview_playlist.get_children():
self.menuchild_gridview_playlist.remove(child)
for child in self.listbox_playlist.get_children():
self.listbox_playlist.remove(child)
self.listbox_playlist.add(self.__create_sidebar_header('Library'))
self.listbox_playlist.add(self.__create_sidebar_row(SongsPlaylist()))
self.listbox_playlist.add(self.__create_sidebar_row(AlbumsPlaylist()))
self.listbox_playlist.add(self.__create_sidebar_row(ArtistsPlaylist()))
self.listbox_playlist.add(self.__create_sidebar_row(UpNextPlaylist(self.player.queue)))
self.listbox_playlist.add(self.__create_sidebar_row(MostPlayedPlaylist()))
self.listbox_playlist.add(self.__create_sidebar_row(RarelyPlayedPlaylist()))
self.listbox_playlist.add(self.__create_sidebar_row(RecentlyPlayedPlaylist()))
self.listbox_playlist.add(self.__create_sidebar_row(RecentlyAddedPlaylist()))
self.listbox_playlist.add(self.__create_sidebar_header('Playlists'))
for playlist in self.player.library.get_playlists():
menu_item = Gtk.MenuItem(label=playlist.name)
menu_item.connect('activate', self.on_menu_gridview_add_to_playlist_activate,
playlist, self.menu_gridview)
self.menuchild_gridview_playlist.append(menu_item)
self.listbox_playlist.add(self.__create_sidebar_row(playlist))
self.menuchild_gridview_playlist.show_all()
self.listbox_playlist.show_all()
def hex_view_populate_popup(self, textview, popup):
disassemble_item = Gtk.MenuItem('Disassemble')
disassemble_item.connect('activate', self.disassemble_item_activate)
separator = Gtk.SeparatorMenuItem()
popup.prepend(separator)
popup.prepend(disassemble_item)
separator.show()
disassemble_item.show()
def create_menu_item(self, menu, name, cmd):
item = gtk.MenuItem(name)
item.connect("activate", self.command_service.send_command_w, cmd)
menu.append(item)
