def popup_menu(icon, button, tm, none):
menu = gtk.Menu()
#item = gtk.ImageMenuItem(gtk.STOCK_QUIT)
#item.connect("activate", quit_finch, None)
#menu.append(item)
item = gtk.ImageMenuItem(gtk.STOCK_CLOSE)
item.connect("activate", close_docklet, None)
menu.append(item)
menu.append(gtk.MenuItem())
item = gtk.CheckMenuItem("Blink for unread IM")
item.set_active(purple.PurplePrefsGetBool("/plugins/dbus/docklet/blink/im"))
item.connect("activate", toggle_pref, "/plugins/dbus/docklet/blink/im")
menu.append(item)
item = gtk.CheckMenuItem("Blink for unread Chats")
item.set_active(purple.PurplePrefsGetBool("/plugins/dbus/docklet/blink/chat"))
item.connect("activate", toggle_pref, "/plugins/dbus/docklet/blink/chat")
menu.append(item)
menu.append(gtk.MenuItem())
#item = pack_image_label(menu, None, "Change Status...")
item = gtk.MenuItem("Change Status...")
menu.append(item)
submenu = gtk.Menu()
item.set_submenu(submenu)
generate_status_menu(submenu)
menu.show_all()
menu.popup(None, None, None, button, tm)
def refresh(self, devices):
"""
Fire this method with the list of devices to display in order to
refresh the menu.
If there is only one device, the "Natural scrolling" menu item will be
a gtk.CheckMenuItem, but if there are more than one devcice, then
"Natural scrolling" menu item will be a gtk.Menu of gtk.CheckMenuItem
per device.
"""
if self.__natural_scrolling:
self.remove(self.__natural_scrolling)
self.__natural_scrolling = None
if len(devices) == 1:
self.__natural_scrolling = gtk.CheckMenuItem("Natural Scrolling")
self.__natural_scrolling.set_tooltip_text(devices[0].keys()[0])
self.__natural_scrolling.connect("toggled",
self.on_natural_scrolling_toggled)
self.__natural_scrolling.show()
else:
self.__natural_scrolling = gtk.MenuItem("Natural Scrolling")
self.__natural_scrolling.show()
devices_menu = gtk.Menu()
for device in devices:
sub_item = gtk.CheckMenuItem(device.values()[0])
sub_item.set_tooltip_text(device.keys()[0])
devices_menu.append(sub_item)
sub_item.connect("toggled", self.on_natural_scrolling_toggled)
sub_item.show()
self.__natural_scrolling.set_submenu(devices_menu)
self.insert(self.__natural_scrolling, 0)
self.sync_checked_items_from_gconf()
def make_menu(event_button, event_time, data=None):
menu = gtk.Menu()
profiles_submenu = gtk.Menu()
profiles_item = gtk.MenuItem("Power Profiles")
profiles_item.set_submenu(profiles_submenu)
performance_item = gtk.MenuItem("High Performance")
balanced_item = gtk.MenuItem("Balanced")
battery_item = gtk.MenuItem("Battery Life")
profiles_submenu.append(performance_item)
profiles_submenu.append(balanced_item)
profiles_submenu.append(battery_item)
graphics_submenu = gtk.Menu()
graphics_item = gtk.MenuItem("Graphics")
graphics_item.set_submenu(graphics_submenu)
intel_item = gtk.CheckMenuItem("Intel Graphics")
nvidia_item = gtk.CheckMenuItem("Nvidia Graphics")
if selected_graphics_card() == "intel":
intel_item.set_active(True)
else:
nvidia_item.set_active(True)
graphics_submenu.append(intel_item)
graphics_submenu.append(nvidia_item)
firmware_item = gtk.MenuItem("Update Firmware")
exit_item = gtk.MenuItem("Exit")
#Append the menu items
menu.append(profiles_item)
menu.append(graphics_item)
menu.append(gtk.SeparatorMenuItem())
menu.append(firmware_item)
menu.append(gtk.SeparatorMenuItem())
menu.append(exit_item)
#add callbacks
performance_item.connect_object("activate", select_power_profile,
"performance")
balanced_item.connect_object("activate", select_power_profile, "balanced")
battery_item.connect_object("activate", select_power_profile, "battery")
intel_item.connect_object("activate", select_graphics_card, "intel")
nvidia_item.connect_object("activate", select_graphics_card, "nvidia")
firmware_item.connect_object("activate", update_firmware, "Firmware")
exit_item.connect_object("activate", exit_app, "Exit")
#Show the menu items
menu.show_all()
#Popup the menu
menu.popup(None, None, None, event_button, event_time)
def __init__(self, main_instance):
""" Constructor """
gtk.Menu.__init__(self)
self.main = main_instance
self.toggle_mute = gtk.CheckMenuItem(_("Mute"))
self.toggle_mute.set_active(self.main.alsactrl.is_muted())
self.mute_handler_id = self.toggle_mute.connect(
"toggled", self.on_toggle_mute)
self.add(self.toggle_mute)
self.toggle_mixer = gtk.CheckMenuItem(_("Show Mixer"))
self.toggle_mixer.set_active(self.main.mixer_get_active())
self.mixer_handler_id = self.toggle_mixer.connect(
"toggled", self.on_toggle_mixer)
self.add(self.toggle_mixer)
item = gtk.ImageMenuItem("gtk-preferences")
item.connect("activate", self.show_preferences)
self.add(item)
item = gtk.ImageMenuItem("gtk-quit")
item.connect("activate", self.main.quit)
self.add(item)
self.show_all()
def generate_menu(self):
"""Generates the checklist menu for all the tabs and attaches it"""
menu = gtk.Menu()
# Create 'All' menuitem and a separator
menuitem = gtk.CheckMenuItem(self.translate_tabs["All"], True)
menuitem.set_name("All")
all_tabs = True
for key in self.tabs:
if not self.tabs[key].is_visible:
all_tabs = False
break
menuitem.set_active(all_tabs)
menuitem.connect("toggled", self._on_menuitem_toggled)
menu.append(menuitem)
menuitem = gtk.SeparatorMenuItem()
menu.append(menuitem)
# Create a list in order of tabs to create menu
menuitem_list = []
for tab_name in self.tabs:
menuitem_list.append((self.tabs[tab_name].weight, tab_name))
menuitem_list.sort()
for pos, name in menuitem_list:
menuitem = gtk.CheckMenuItem(self.translate_tabs[name], True)
menuitem.set_name(name)
menuitem.set_active(self.tabs[name].is_visible)
menuitem.connect("toggled", self._on_menuitem_toggled)
menu.append(menuitem)
self.menu_tabs.set_submenu(menu)
self.menu_tabs.show_all()
def get_menuitems(self):
"""Return the menuitems specific to this view."""
items = []
self.headings_menu_item = gtk.CheckMenuItem(
'Toggle _Hide Task Headings')
self.headings_menu_item.set_active(self.t.should_hide_headings)
items.append(self.headings_menu_item)
self.headings_menu_item.show()
self.headings_menu_item.connect('toggled', self.toggle_headings)
self.group_menu_item = gtk.CheckMenuItem('Toggle _Family Grouping')
self.group_menu_item.set_active(self.t.should_group_families)
items.append(self.group_menu_item)
self.group_menu_item.connect('toggled', self.toggle_grouping)
self.transpose_menu_item = gtk.CheckMenuItem('Toggle _Transpose View')
self.transpose_menu_item.set_active(self.t.should_transpose_view)
items.append(self.transpose_menu_item)
self.transpose_menu_item.connect('toggled', self.toggle_transpose)
if self.cfg.use_defn_order:
self.defn_order_menu_item = gtk.CheckMenuItem(
'Toggle _Definition Order')
self.defn_order_menu_item.set_active(self.t.defn_order_on)
items.append(self.defn_order_menu_item)
self.defn_order_menu_item.connect('toggled',
self.toggle_defn_order)
return items
def menu_setup(self):
self.menu = gtk.Menu()
self.BTCtickers = None
self.btceBTC = gtk.RadioMenuItem(self.BTCtickers, "BTC-E")
self.btceBTC.connect("activate",
lambda x: self.toggleBTCdisplay("btce"))
self.btceBTC.show()
self.BTCtickers = self.btceBTC
self.mtgoxBTC = gtk.RadioMenuItem(self.BTCtickers, "MtGox")
self.mtgoxBTC.connect("activate",
lambda x: self.toggleBTCdisplay("mtgox"))
self.mtgoxBTC.show()
self.BTCtickers = self.mtgoxBTC
self.bitstampBTC = gtk.RadioMenuItem(self.BTCtickers, "BitStamp")
self.bitstampBTC.connect("activate",
lambda x: self.toggleBTCdisplay("bitstamp"))
self.bitstampBTC.show()
self.BTCtickers = self.bitstampBTC
self.blockchainBTC = gtk.RadioMenuItem(self.BTCtickers, "BlockChain")
self.blockchainBTC.connect(
"activate", lambda x: self.toggleBTCdisplay("blockchain"))
self.blockchainBTC.show()
self.BTCtickers = self.blockchainBTC
self.defSet = gtk.MenuItem("Choose exchange : ")
self.defSet.show()
self.menu.append(self.defSet)
self.menu.append(self.mtgoxBTC)
self.menu.append(self.btceBTC)
self.menu.append(self.bitstampBTC)
self.menu.append(self.blockchainBTC)
self.setRefreshMenu(self.menu)
self.ltcAdd = gtk.CheckMenuItem("LTC Price")
self.ltcAdd.connect("activate", self.initLTCAddOn)
if self.LTCMODE:
self.ltcAdd.activate()
self.ltcAdd.show()
self.menu.append(self.ltcAdd)
self.nmcAdd = gtk.CheckMenuItem("NMC Price")
self.nmcAdd.connect("activate", self.initNMCAddOn)
if self.NMCMODE:
self.nmcAdd.activate()
self.nmcAdd.show()
self.menu.append(self.nmcAdd)
self.getNewPricesBTC()
self.about = gtk.MenuItem("About")
self.about.connect("activate", self.menu_about_response)
self.about.show()
self.menu.append(self.about)
self.quit_item = gtk.MenuItem("Quit Indicator")
self.quit_item.connect("activate", self.quit)
self.quit_item.show()
self.menu.append(self.quit_item)
def get_menuitems(self):
"""Return the menu items specific to this view."""
items = []
autoex_item = gtk.CheckMenuItem('Toggle _Auto-Expand Tree')
autoex_item.set_active(self.t.autoexpand)
items.append(autoex_item)
autoex_item.connect('activate', self.toggle_autoexpand)
self.group_menu_item = gtk.CheckMenuItem('Toggle _Family Grouping')
self.group_menu_item.set_active(self.t.should_group_families)
items.append(self.group_menu_item)
self.group_menu_item.connect('toggled', self.toggle_grouping)
return items
def populate_popup_cb(self, webview, menu):
item = gtk.MenuItem(label="Source Edition")
menu.append(item)
submenu = gtk.Menu()
menuitem = gtk.MenuItem(label="Loaded Source or File Source")
menuitem.connect('activate', self.edit_source_activated_cb)
submenu.append(menuitem)
menuitem = gtk.MenuItem(label="Interpreted Source (JS useful)")
menuitem.connect('activate', self.edit_loaded_activated_cb)
submenu.append(menuitem)
item.set_submenu(submenu)
# -------------------------------
menu.append(gtk.SeparatorMenuItem())
# -------------------------------
item = gtk.ImageMenuItem(stock_id=gtk.STOCK_HOME)
item.connect('activate', self.go_home_activated_cb)
item.set_property('label', 'Starting Page')
menu.append(item)
# -------------------------------
menu.append(gtk.SeparatorMenuItem())
# -------------------------------
self.append_plugins_submenu(menu)
item = gtk.MenuItem(label="Server Config")
menu.append(item)
submenu = gtk.Menu()
menuitem = gtk.CheckMenuItem(label="Enable Server")
menuitem.connect('toggled', self.toggle_serveur_activated_cb)
menuitem.set_property('active', self.flag_serveur)
submenu.append(menuitem)
menuitem = gtk.RadioMenuItem(None, "Localhost Acces Only")
menuitem.connect('toggled', self.toggle_local_acces_activated_cb)
menuitem.set_property('active', self.flag_local_acces)
menuitem.set_property('sensitive', self.flag_serveur)
submenu.append(menuitem)
menuitem = gtk.RadioMenuItem(menuitem, "Global Acces")
menuitem.connect('toggled', self.toggle_general_acces_activated_cb)
menuitem.set_property('active', not self.flag_local_acces)
menuitem.set_property('sensitive', self.flag_serveur)
submenu.append(menuitem)
item.set_submenu(submenu)
# -------------------------------
menu.append(gtk.SeparatorMenuItem())
# -------------------------------
item = gtk.CheckMenuItem(label="Auto Refresh")
item.connect('toggled', self.toggle_auto_refresh_cb)
item.set_property('active', self.auto_refresh)
menu.append(item)
item = gtk.MenuItem(label="Panel location")
item.connect('activate', self.toggle_view_activated_cb)
menu.append(item)
menu.show_all()
def get_menuitems(self):
"""Return the menu items specific to this view."""
items = []
graph_range_item = gtk.MenuItem('Time Range Focus ...')
items.append(graph_range_item)
graph_range_item.connect('activate', self.graph_timezoom_popup)
crop_item = gtk.CheckMenuItem('Toggle _Crop Base Graph')
items.append(crop_item)
crop_item.set_active(self.t.crop)
crop_item.connect('activate', self.toggle_crop)
self.menu_group_item = gtk.ImageMenuItem('_Group All Families')
img = gtk.image_new_from_stock('group', gtk.ICON_SIZE_MENU)
self.menu_group_item.set_image(img)
items.append(self.menu_group_item)
self.menu_group_item.connect('activate', self.group_all, True)
self.menu_ungroup_item = gtk.ImageMenuItem('_UnGroup All Families')
img = gtk.image_new_from_stock('ungroup', gtk.ICON_SIZE_MENU)
self.menu_ungroup_item.set_image(img)
items.append(self.menu_ungroup_item)
self.menu_ungroup_item.connect('activate', self.group_all, False)
menu_left_to_right_item = gtk.CheckMenuItem(
'_Transpose Graph')
items.append(menu_left_to_right_item)
menu_left_to_right_item.set_active(self.t.orientation == "LR")
menu_left_to_right_item.connect('activate',
self.toggle_left_to_right_mode)
self.menu_subgraphs_item = gtk.CheckMenuItem(
'_Organise by Cycle Point')
items.append(self.menu_subgraphs_item)
self.menu_subgraphs_item.set_active(self.t.subgraphs_on)
self.menu_subgraphs_item.connect('activate',
self.toggle_cycle_point_subgraphs)
igsui_item = gtk.CheckMenuItem('_Ignore Suicide Triggers')
items.append(igsui_item)
igsui_item.set_active(self.t.ignore_suicide)
igsui_item.connect('activate', self.toggle_ignore_suicide_triggers)
self.menu_frames_item = gtk.CheckMenuItem('_Write Graph Frames')
items.append(self.menu_frames_item)
self.menu_frames_item.set_active(self.t.write_dot_frames)
self.menu_frames_item.connect(
'activate', self.toggle_write_dot_frames)
return items
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 on_populate_popup(self, treeview, menu):
# Add a popup menu item to switch the treeview mode
populate_popup_add_separator(menu, prepend=True)
item = gtk.CheckMenuItem(_('Show full page name')) # T: menu option
item.set_active(self.uistate['show_full_page_name'])
item.connect_object('toggled',
self.__class__.toggle_show_full_page_name, self)
menu.prepend(item)
item = gtk.CheckMenuItem(_('Sort pages by tags')) # T: menu option
item.set_active(self.uistate['treeview'] == 'tags')
item.connect_object('toggled', self.__class__.toggle_treeview, self)
menu.prepend(item)
menu.show_all()
def create_checklist_menu(self):
"""Creates a menu used for toggling the display of columns."""
menu = self.menu = gtk.Menu()
# Iterate through the column_index list to preserve order
for name in self.column_index:
column = self.columns[name]
# If the column is hidden, then we do not want to show it in the
# menu.
if column.hidden is True:
continue
menuitem = gtk.CheckMenuItem(column.name)
# If the column is currently visible, make sure it's set active
# (or checked) in the menu.
if column.column.get_visible() is True:
menuitem.set_active(True)
# Connect to the 'toggled' event
menuitem.connect('toggled', self.on_menuitem_toggled)
# Add the new checkmenuitem to the menu
menu.append(menuitem)
# Attach this new menu to all the checklist_menus
for _menu in self.checklist_menus:
_menu.set_submenu(menu)
_menu.show_all()
return menu
def open_menu(self, icon, button, time):
"""
The right click action for the status icon; launches a menu with
various options
"""
menu = gtk.Menu()
menu.set_border_width(5)
config = gtk.MenuItem("Configure")
about = gtk.MenuItem("About")
quit = gtk.MenuItem("Quit")
config.connect("activate", self.show_config_dialog)
about.connect("activate", self.show_about_dialog)
quit.connect("activate", self.quit)
silenced = gtk.CheckMenuItem("Silence Mail")
silenced.connect("button-press-event", self.toggle_silenced)
silenced.set_active(self.silenced)
menu.append(config)
menu.append(silenced)
menu.append(about)
menu.append(quit)
menu.show_all()
menu.popup(None, None, gtk.status_icon_position_menu, button, time,
self.statusicon)
def __init__(self, args):
# Load the database
home = expanduser("~")
with open(home + '/.hackertray.json', 'a+') as content_file:
content_file.seek(0)
content = content_file.read()
try:
self.db = set(json.loads(content))
except ValueError:
self.db = set()
# create an indicator applet
self.ind = appindicator.Indicator("Hacker Tray", "hacker-tray", appindicator.CATEGORY_APPLICATION_STATUS)
self.ind.set_status(appindicator.STATUS_ACTIVE)
self.ind.set_icon(get_icon_filename("hacker-tray.png"))
# create a menu
self.menu = gtk.Menu()
# The default state is false, and it toggles when you click on it
self.commentState = args.comments
# create items for the menu - refresh, quit and a separator
menuSeparator = gtk.SeparatorMenuItem()
menuSeparator.show()
self.menu.append(menuSeparator)
btnComments = gtk.CheckMenuItem("Show Comments")
btnComments.show()
btnComments.set_active(args.comments)
btnComments.connect("activate", self.toggleComments)
self.menu.append(btnComments)
btnAbout = gtk.MenuItem("About")
btnAbout.show()
btnAbout.connect("activate", self.showAbout)
self.menu.append(btnAbout)
btnRefresh = gtk.MenuItem("Refresh")
btnRefresh.show()
# the last parameter is for not running the timer
btnRefresh.connect("activate", self.refresh, True, args.chrome)
self.menu.append(btnRefresh)
if Version.new_available():
btnUpdate = gtk.MenuItem("New Update Available")
btnUpdate.show()
btnUpdate.connect('activate', self.showUpdate)
self.menu.append(btnUpdate)
btnQuit = gtk.MenuItem("Quit")
btnQuit.show()
btnQuit.connect("activate", self.quit)
self.menu.append(btnQuit)
self.menu.show()
self.ind.set_menu(self.menu)
self.refresh(chrome_data_directory=args.chrome, firefox_data_directory=args.firefox)
self.launch_analytics(args)
def createMenu(self):
menu = gtk.Menu()
item = gtk.MenuItem("Select _All")
menu.append(item)
item.connect("activate", self.selectAll)
item.show()
item = gtk.MenuItem("Save Selected Data...")
menu.append(item)
item.connect("activate", self.saveSelectedData)
item.show()
item = gtk.CheckMenuItem("Follow Log")
item.set_active(self.followLog)
menu.append(item)
item.connect("activate", self.followLogToggled)
item.show()
item = gtk.MenuItem("Filter")
item.set_submenu(self.createFilterMenu())
menu.append(item)
item.show()
return menu
def __init__(self, controller, msn, action=None):
'''Contructor'''
self.theme = controller.theme
self.sound = Sound(self.theme)
self.controller = controller
self.config = self.controller.config
self.msn = msn
self.muteSound = self.config.user['soundsmuteSound']
self.checkBox = gtk.CheckMenuItem(_('Mute Sounds'))
self.checkBox.set_active(self.muteSound)
if action == 'start':
self.onlineId = None
self.offlineId = None
self.messageId = None
self.nudgeId = None
self.transferId = None
self.sendMessageId = None
self.connectpbId = None
self.senderrorId = None
self.exceptionId = None
self.errorId = None
self.check()
self.checkBox.connect('activate', self.on_muteSounds_activate)
self.updateTrayIconMenuList()
self.update()
self.start()
def make_menu(self):
self.menu = menu = gtk.Menu()
show_item = gtk.CheckMenuItem(_("Show keys"))
show_item.set_active(True)
show_item.connect("toggled", self.on_show_keys)
show_item.show()
menu.append(show_item)
preferences_item = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES)
preferences_item.connect("activate", self.on_preferences_dialog)
preferences_item.show()
menu.append(preferences_item)
about_item = gtk.ImageMenuItem(gtk.STOCK_ABOUT)
about_item.connect("activate", self.on_about_dialog)
about_item.show()
menu.append(about_item)
separator_item = gtk.SeparatorMenuItem()
separator_item.show()
menu.append(separator_item)
image = gtk.ImageMenuItem(gtk.STOCK_QUIT)
image.connect("activate", self.quit)
image.show()
menu.append(image)
menu.show()
def on_populate_popup(self, view, menu):
menu.prepend(gtk.SeparatorMenuItem())
def activate_linenumbers(item):
self.show_line_numbers(item.get_active())
item = gtk.CheckMenuItem(_('Show Line Numbers'))
item.set_active(self._attrib['linenumbers'] == 'true') # FIXME - make this attrib boolean
item.connect_after('activate', activate_linenumbers)
menu.prepend(item)
def activate_lang(item):
self.set_language(item.zim_sourceview_languageid)
item = gtk.MenuItem(_('Syntax'))
submenu = gtk.Menu()
for lang in sorted(LANGUAGES, key=lambda k: k.lower()):
langitem = gtk.MenuItem(lang)
langitem.connect('activate', activate_lang)
langitem.zim_sourceview_languageid = LANGUAGES[lang]
submenu.append(langitem)
item.set_submenu(submenu)
menu.prepend(item)
menu.show_all()
def create_context_menu(self):
"""Create a context menu on right click."""
menu = gtk.Menu()
toggle_chrome = gtk.CheckMenuItem(_('Window _Chrome'))
toggle_chrome.set_active(self.window.get_decorated())
toggle_chrome.connect_object('activate', self.toggle_chrome,
self.window.get_decorated())
toggle_chrome.show()
menu.append(toggle_chrome)
settings_click = gtk.MenuItem(_('_Settings...\tCtrl-S'))
settings_click.connect_object('activate', self.show_settings_dlg, None)
settings_click.show()
menu.append(settings_click)
about_click = gtk.MenuItem(_('_About...'))
about_click.connect_object('activate', self.show_about_dlg, None)
about_click.show()
menu.append(about_click)
quitcmd = gtk.MenuItem(_('_Quit\tCtrl-Q'))
quitcmd.connect_object('activate', self.destroy, None)
quitcmd.show()
menu.append(quitcmd)
return menu
def setup_context_menu(self):
"""Add options to the context menu.
"""
menu = self.applet.dialog.menu
menu_index = len(menu) - 1
self.context_menu_unit = gtk.CheckMenuItem(
label=_('Use KBps instead of Kbps'))
if self.unit == 1:
self.context_menu_unit.set_active(True)
def menu_opened(widget):
self.context_menu_unit.disconnect(self.context_menu_unit_handler)
self.context_menu_unit.set_active(self.unit == 1)
self.context_menu_unit_handler = self.context_menu_unit.connect(
'toggled', self.call_change_unit)
menu.connect("show", menu_opened)
self.context_menu_unit_handler = self.context_menu_unit.connect(
'toggled', self.call_change_unit)
menu.insert(self.context_menu_unit, menu_index)
iface_submenu = self.generate_iface_submenu()
self.iface_submenu = iface_submenu
map_item = gtk.MenuItem(_("Interfaces"))
map_item.set_submenu(iface_submenu)
menu.insert(map_item, menu_index + 1)
menu.insert(gtk.SeparatorMenuItem(), menu_index + 2)
def make_popup(self):
menu = gtk.Menu()
no_music = 'no-music'
names = self.config.keys()
for name in [no_music] + sorted(names):
real_name = 'None'
if name in self.config:
real_name = self.config[name]['name']
if name == self.playlist or (name == no_music
and self.playlist == None):
item = gtk.CheckMenuItem(real_name)
item.set_active(True)
else:
item = gtk.MenuItem(real_name)
def make_click(name):
def click(object):
if name == no_music:
self.stop_music()
else:
self.play_music(name)
return click
item.connect('activate', make_click(name))
item.show()
menu.append(item)
menu.popup(None, None, None, 0, gtk.get_current_event_time())
def _add_item_to_platform_menu(self, item, name, command = None, index = None):
checked = item.checked
if checked is None:
gtk_item = gtk.MenuItem(name)
else:
gtk_item = gtk.CheckMenuItem(name)
self._gtk_add_item(gtk_item)
if not item.enabled:
gtk_item.set_sensitive(0)
if checked:
gtk_item.set_active(1)
if command:
app = application()
if index is not None:
action = lambda widget: app.dispatch(command, index)
else:
action = lambda widget: app.dispatch(command)
gtk_item.connect('activate', action)
key = item._key
if key:
gtk_modifiers = gdk.CONTROL_MASK
if item._shift:
gtk_modifiers |= gdk.SHIFT_MASK
if item._option:
gtk_modifiers |= gdk.MOD1_MASK
gtk_item.add_accelerator('activate', self._gtk_accel_group,
ord(key), gtk_modifiers, gtk.ACCEL_VISIBLE)
def build_menu(self):
self.menu = gtk.Menu()
self.switch = gtk.CheckMenuItem()
self.initial_state_checker()
self.switch.set_sensitive(False)
self.menu.append(self.switch)
self.build_menu_separator(self.menu)
self.prefered_app_submenu = gtk.MenuItem("Preferred Apps")
self.update_menu()
self.prefered_app_submenu.connect('activate', self.update_menu)
self.menu.append(self.prefered_app_submenu)
item2 = gtk.MenuItem("Configure Apps")
item2.connect("activate", self.app_configure)
self.menu.append(item2)
#TODO An UI to configure Bumblebee would be nice
self.build_menu_separator(self.menu)
quit = gtk.ImageMenuItem(gtk.STOCK_QUIT)
quit.connect("activate", self.quit)
self.menu.append(quit)
self.menu.show_all()
def create_menu_items_from_view(menu, items):
# TODO: images & radio groups, for now only basic representation
for item in items:
if item.type is MenuItemView.COMMAND:
it = gtk.MenuItem(item.label)
it.connect("activate", lambda i, item: item.command(), item )
it.show()
menu.append(it)
elif item.type is MenuItemView.CASCADE_MENU:
men = gtk.Menu()
it = gtk.MenuItem(item.label)
create_menu_items_from_view(men, item.items)
it.set_submenu(men)
it.show()
menu.append(it)
elif item.type is MenuItemView.SEPARATOR:
it = gtk.SeperatorMenuItem()
it.show()
menu.append(it)
elif item.type is MenuItemView.CHECKBUTTON:
it = gtk.CheckMenuItem(item.label)
if item.checkbox:
it.set_active()
it.show()
menu.append(it)
elif item.type is MenuItemView.RADIOBUTTON:
it = gtk.RadioMenuItem(item.label)
it.show()
menu.append(it)
elif item.type is MenuItemView.RADIOBUTTONGROUP:
pass
def show_menu(self, event):
#Create the menu and menu items if they don't exist
if not self.menu:
#Create the items
add_feed = awn.image_menu_item_new_with_label(_("Add Feed"))
update = gtk.ImageMenuItem(gtk.STOCK_REFRESH)
self.show_only_new_check = gtk.CheckMenuItem(_("Show Only _New Feeds"))
sep = gtk.SeparatorMenuItem()
prefs_item = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES)
about = gtk.ImageMenuItem(_("_About %s") % _("Feeds Applet"))
about.props.always_show_image = True
about.set_image(gtk.image_new_from_stock(gtk.STOCK_ABOUT, gtk.ICON_SIZE_MENU))
#Add icon for "Add Feed"
add_icon = gtk.image_new_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_MENU)
add_feed.set_image(add_icon)
if self.client.get_value(GROUP_DEFAULT, 'show_only_new'):
self.show_only_new_check.set_active(True)
add_feed.connect('activate', self.add_feed_dialog)
update.connect('activate', self.update_feeds)
self.show_only_new_check.connect('toggled', self.toggle_show_only_new)
prefs_item.connect('activate', self.open_prefs)
about.connect('activate', self.show_about)
#Create the menu
self.menu = self.create_default_menu()
for item in (add_feed, update, self.show_only_new_check, sep, prefs_item, about):
self.menu.append(item)
self.menu.show_all()
self.popup_gtk_menu (self.menu, event.button, event.time)
def _CheckOOFMenuItem_construct_gui(self, base, parent_menu, accelgroup):
debug.mainthreadTest()
new_gtkitem = gtk.CheckMenuItem()
new_gtkitem.add(self.gtklabel(new_gtkitem))
gtklogger.setWidgetName(new_gtkitem, self.name)
try:
self.gtkitem.append(new_gtkitem)
except AttributeError:
self.gtkitem = [new_gtkitem]
new_gtkitem.connect("destroy", self.gtkitem_destroyed)
# Set the state of the button. This calls the callback, so we do
# it here before the callback is connected.
new_gtkitem.set_active(self.value)
if self.accel is not None and accelgroup is not None:
new_gtkitem.add_accelerator('activate', accelgroup, ord(self.accel),
gtk.gdk.MOD1_MASK, gtk.ACCEL_VISIBLE)
# Handler IDs are added in the same order as items, so there
# is item-for-item correspondence of the lists.
new_handler = gtklogger.connect(new_gtkitem, 'activate',
CheckMenuCallBackWrapper(self))
try:
self.handlerid.append(new_handler)
except AttributeError:
self.handlerid = [new_handler]
if not self.enabled():
new_gtkitem.set_sensitive(0)
parent_menu.insert(new_gtkitem, self.gui_order())
def add_check_menu_item(self, label, command, menu=None, value=True):
item = gtk.CheckMenuItem(label)
item.set_active(value)
item.connect('activate', self.handle_menu_item, command)
if menu is None:
menu = self.menu
menu.append(item)
def _make_axis_menu(self):
# called by self._update*()
def toggled(item, data=None):
if item == self.itemAll:
for item in items:
item.set_active(True)
elif item == self.itemInvert:
for item in items:
item.set_active(not item.get_active())
ind = [i for i, item in enumerate(items) if item.get_active()]
self.set_active(ind)
menu = gtk.Menu()
self.itemAll = gtk.MenuItem("All")
menu.append(self.itemAll)
self.itemAll.connect("activate", toggled)
self.itemInvert = gtk.MenuItem("Invert")
menu.append(self.itemInvert)
self.itemInvert.connect("activate", toggled)
items = []
for i in range(len(self._axes)):
item = gtk.CheckMenuItem("Axis %d" % (i + 1))
menu.append(item)
item.connect("toggled", toggled)
item.set_active(True)
items.append(item)
menu.show_all()
return menu
def _item_checkbox(self, item):
"""Create checkbox menu item"""
active = item['active'] if 'active' in item else False
result = gtk.CheckMenuItem(label=item['label'], use_underline=True)
result.set_active(active)
return result
