def _menu_action_pressed(widget, event):
menu = _hamburger_menu
guiutils.remove_children(menu)
menu.add(
guiutils.get_menu_item(_("Cancel Selected Render"),
_hamburger_item_activated, "cancel_selected"))
menu.add(
guiutils.get_menu_item(_("Cancel All Renders"),
_hamburger_item_activated, "cancel_all"))
guiutils.add_separetor(menu)
sequential_render_item = Gtk.CheckMenuItem()
sequential_render_item.set_label(_("Render All Jobs Sequentially"))
sequential_render_item.set_active(
editorpersistance.prefs.render_jobs_sequentially)
sequential_render_item.connect("activate", _hamburger_item_activated,
"sequential_render")
menu.add(sequential_render_item)
open_on_add_item = Gtk.CheckMenuItem()
open_on_add_item.set_label(_("Show Jobs Panel on Adding New Job"))
open_on_add_item.set_active(editorpersistance.prefs.open_jobs_panel_on_add)
open_on_add_item.connect("activate", _hamburger_item_activated,
"open_on_add")
menu.add(open_on_add_item)
menu.show_all()
menu.popup(None, None, None, None, event.button, event.time)
def create_menu(self, active, primary, resolution, active_resolution):
self.menu = Gtk.Menu()
prim = Gtk.CheckMenuItem("Primary")
prim.set_active(primary)
prim.connect("activate", self.menu_change_stat_primary)
self.menu.append(prim)
act = Gtk.CheckMenuItem("Active")
act.set_active(active)
act.connect("activate", self.menu_change_stat_active)
self.menu.append(act)
res_submenu = Gtk.Menu()
menu = None
for r in resolution:
title = str(r[0]) + "x" + str(r[1])
menu = Gtk.RadioMenuItem(title, group=menu)
if title == active_resolution:
menu.set_active(True)
menu.connect("activate", self.menu_change_resolution, r[0], r[1])
res_submenu.append(menu)
res = Gtk.MenuItem("Resolution")
res.set_submenu(res_submenu)
self.menu.append(res)
self.menu.show_all()
def on_gremlin_clicked(self, widget, event, data=None):
if event.type == Gdk.EventType.DOUBLE_BUTTON_PRESS:
self.clear_live_plotter()
# Settings
if event.type == Gdk.EventType.BUTTON_PRESS and event.button == 3:
menu = Gtk.Menu()
program_alpha = Gtk.CheckMenuItem("Program alpha")
program_alpha.set_active(self.program_alpha)
program_alpha.connect("activate", self.toggle_program_alpha)
menu.append(program_alpha)
show_limits = Gtk.CheckMenuItem("Show limits")
show_limits.set_active(self.show_limits)
show_limits.connect("activate", self.toggle_show_limits)
menu.append(show_limits)
show_extents = Gtk.CheckMenuItem("Show extents")
show_extents.set_active(self.show_extents_option)
show_extents.connect("activate", self.toggle_show_extents_option)
menu.append(show_extents)
live_plot = Gtk.CheckMenuItem("Show live plot")
live_plot.set_active(self.show_live_plot)
live_plot.connect("activate", self.toggle_show_live_plot)
menu.append(live_plot)
# lathe = gtk.CheckMenuItem("Lathe mode")
# lathe.set_active(self.lathe_option )
# lathe.connect("activate", self.toggle_lathe_option)
# menu.append(lathe)
menu.popup(None, None, None, event.button, event.time)
menu.show_all()
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 get_popup_filter_menu(self):
# create filter menu and menuitems
filter_menu = Gtk.Menu()
menu_item_expired = Gtk.CheckMenuItem('Expired campaigns')
menu_item_user = Gtk.CheckMenuItem('Your campaigns')
menu_item_other = Gtk.CheckMenuItem('Other campaigns')
self.filter_menu_items = {
'expired_campaigns': menu_item_expired,
'your_campaigns': menu_item_user,
'other_campaigns': menu_item_other
}
# set up the menuitems and add it to the menubutton
for menus in self.filter_menu_items:
filter_menu.append(self.filter_menu_items[menus])
self.filter_menu_items[menus].connect(
'toggled', self.signal_checkbutton_toggled)
self.filter_menu_items[menus].show()
self.filter_menu_items['expired_campaigns'].set_active(
self.config['filter.campaign.expired'])
self.filter_menu_items['your_campaigns'].set_active(
self.config['filter.campaign.user'])
self.filter_menu_items['other_campaigns'].set_active(
self.config['filter.campaign.other_users'])
self.gobjects['menubutton_filter'].set_popup(filter_menu)
filter_menu.connect('destroy', self._save_filter)
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 _on_button_release(self, treeview, event):
if event.button != 3:
return False
pos = treeview.get_path_at_pos(int(event.x), int(event.y))
if not pos:
return False
row = self._model[pos[0]]
if row[Row.HasState] and not row[Row.State]:
return False
if not self._row_menu:
self._row_menu = Gtk.Menu()
self._row_menu_reset = Gtk.MenuItem(
C_('option-entry|indicators', 'Reset to _defaults'))
self._row_menu_text = Gtk.CheckMenuItem(
C_('option-entry|indicators', 'Display _label'))
self._row_menu_image = Gtk.CheckMenuItem(
C_('option-entry|indicators', 'Display _image'))
self._row_menu_remove = Gtk.MenuItem(
C_('option-entry|indicators', '_Remove'))
self._row_menu_text_id = self._row_menu_text.connect(
'toggled', self._on_row_menu_toggled, Option.Text)
self._row_menu_image_id = self._row_menu_image.connect(
'toggled', self._on_row_menu_toggled, Option.Image)
self._row_menu_reset.connect('activate',
self._on_row_menu_reset_clicked)
self._row_menu_remove.connect('activate', self._on_remove_clicked)
self._row_menu.append(self._row_menu_reset)
self._row_menu.append(self._row_menu_text)
self._row_menu.append(self._row_menu_image)
self._row_menu.append(Gtk.SeparatorMenuItem())
self._row_menu.append(self._row_menu_remove)
for item in self._row_menu:
if type(item) is not Gtk.SeparatorMenuItem:
item.props.use_underline = True
item.props.visible = True
options = row[Row.Options].data
with self._row_menu_text.handler_block(self._row_menu_text_id):
self._row_menu_text.props.active = Option.Text in options
with self._row_menu_image.handler_block(self._row_menu_image_id):
self._row_menu_image.props.active = Option.Image in options
editable = options[Option.Name] not in {
Indicators.Spacer, Indicators.Separator
}
self._row_menu_reset.props.sensitive = editable
self._row_menu_text.props.sensitive = editable
self._row_menu_image.props.sensitive = editable
self._row_menu.popup(None, None, None, None, 0,
Gtk.get_current_event_time())
return True
def __update_menu(self):
menu = gtk.Menu()
for crypto_currency in self.prices:
item = gtk.MenuItem(
self.__get_exchange_price_label(crypto_currency,
self.prices[crypto_currency]))
item.connect('activate', self.__open_store)
menu.append(item)
menu.append(gtk.SeparatorMenuItem())
item_refresh = gtk.MenuItem('Refresh prices')
item_refresh.connect('activate', lambda _: self.refresh_fc())
menu.append(item_refresh)
menu.append(gtk.SeparatorMenuItem())
crypto_currency_options = self.config.get_crypto_currency_options()
for crypto_currency in crypto_currency_options:
crypto_currency_sub_menu = gtk.Menu()
for option_key in crypto_currency_options[crypto_currency]:
item = gtk.CheckMenuItem(
crypto_currency_options[crypto_currency]
[option_key].get_label(),
active=crypto_currency_options[crypto_currency]
[option_key].get_status())
item.connect(
"activate", lambda _, currency, key: self.
__toggle_crypto_currency_option_status(currency, key),
crypto_currency, option_key)
crypto_currency_sub_menu.append(item)
crypto_currency_item = gtk.MenuItem(crypto_currency)
crypto_currency_item.set_submenu(crypto_currency_sub_menu)
menu.append(crypto_currency_item)
menu.append(gtk.SeparatorMenuItem())
general_settings_sub_menu = gtk.Menu()
options = self.config.get_general_options()
for option_key in options:
item = gtk.CheckMenuItem(options[option_key].get_label(),
active=options[option_key].get_status())
item.connect(
"activate",
lambda _, key: self.__toggle_general_option_status(key),
option_key)
general_settings_sub_menu.append(item)
general_settings_item = gtk.MenuItem('Settings')
general_settings_item.set_submenu(general_settings_sub_menu)
menu.append(general_settings_item)
menu.append(gtk.SeparatorMenuItem())
item_quit = gtk.MenuItem('Quit')
item_quit.connect('activate', lambda _: self.quit_fc())
menu.append(item_quit)
menu.show_all()
self.indicator.set_menu(menu)
def update_device_list(self):
disconnected_devs, connected_devs = self.update_bluetooth_devices()
if self.connected_devs != connected_devs:
opened_devices = self.get_opened_terminals()
for dev in self.connect_menu:
self.connect_menu.remove(dev)
for dev in connected_devs:
dev_menu_item = Gtk.CheckMenuItem(
self.get_device_name(dev) + ' (' + dev + ')')
if dev in opened_devices:
dev_menu_item.set_active(True)
self.connect_to_device(dev)
dev_menu_item.connect("activate", self.connect_disconnect)
self.connect_menu.append(dev_menu_item)
self.connect_menu.show_all()
self.update_terminal_devices(disconnected_devs, connected_devs)
# When there are no connected NUS devices, show info in menu
items = [item for item in self.connect_menu]
if not items:
no_bonded_menu_item = Gtk.CheckMenuItem(
'No compatible devices connected')
self.connect_menu.append(no_bonded_menu_item)
self.connect_menu.show_all()
self.disconnected_devs = disconnected_devs
self.connected_devs = connected_devs
time.sleep(0.01)
return True
def __init__(self, controls):
Gtk.Box.__init__(self,
orientation=Gtk.Orientation.HORIZONTAL,
spacing=0)
self.order = ToggleImageButton("edit-redo", size=Gtk.IconSize.BUTTON)
self.order.connect("button-press-event", self.on_order)
self.pack_start(self.order, False, False, 0)
self.repeat = ToggleImageButton("view-refresh",
size=Gtk.IconSize.BUTTON)
self.repeat.connect("button-press-event", self.choise)
try:
self.order.set_has_tooltip(True)
self.repeat.set_has_tooltip(True)
except:
pass
self.pack_start(self.repeat, False, False, 0)
self.menu = Gtk.Menu()
self.item_all = Gtk.CheckMenuItem(_("Repeat all"))
self.item_all.connect("button-press-event", self.on_repeat)
self.menu.append(self.item_all)
self.item_single = Gtk.CheckMenuItem(_("Repeat single"))
self.item_single.connect("button-press-event",
lambda item, *a: self.on_repeat(item, False))
self.menu.append(self.item_single)
def build_ui(self):
self.tray = tray = Gtkti.TrayIcon()
eventbox = Gtk.EventBox()
if background_color:
css = Gtk.CssProvider()
css.load_from_data(
('* { background-color: ' + background_color + '; }').encode())
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), css,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
tray.add(eventbox)
self.tray_label = tray_label = Gtk.Label(label=self.prefix +
self.suffix)
eventbox.add(tray_label)
tray.show_all()
menu = Gtk.Menu()
item_show_date = Gtk.CheckMenuItem(label='Show Date')
item_show_date.set_active(self.show_date)
def toggle_date(item_show_date, self=self):
self.show_date = item_show_date.get_active()
self.gtk_update_ui()
item_show_date.connect('toggled', toggle_date)
menu.append(item_show_date)
item_show_seconds = Gtk.CheckMenuItem(label='Show Seconds')
item_show_seconds.set_active(self.show_seconds)
self.toggle_seconds_event = threading.Event()
def toggle_seconds(item_show_seconds, self=self):
self.show_seconds = item_show_seconds.get_active()
# Wake the update thread, which will update the UI, then sleep again
self.toggle_seconds_event.set()
item_show_seconds.connect('toggled', toggle_seconds)
menu.append(item_show_seconds)
item_quit = Gtk.MenuItem(label='Quit')
def quit(menu_item):
if sys.version_info < (3, 0):
os.kill(os.getpid(), signal.SIGINT)
else:
Gtk.main_quit()
item_quit.connect('activate', quit)
menu.append(item_quit)
menu.show_all()
def button_pressed(eventbox, event, menu=menu):
if event.type == Gdk.EventType.BUTTON_PRESS and event.button == 3:
menu.popup(None, None, None, None, event.button, event.time)
eventbox.connect('button-press-event', button_pressed)
def _add_prefs_menu(self, oPrefsMenu):
"""Add the File Preferences menu"""
self._dMenus["File Preferences"] = oPrefsMenu
oCheckForUpdates = Gtk.CheckMenuItem(label='Check for Cardlist updates'
' on startup')
oCheckForUpdates.set_inconsistent(False)
if self._oConfig.get_check_for_updates():
oCheckForUpdates.set_active(True)
else:
oCheckForUpdates.set_active(False)
oCheckForUpdates.connect('activate', self.do_toggle_check_for_updates)
oPrefsMenu.add(oCheckForUpdates)
oNameDisplay = Gtk.CheckMenuItem(
label='Use "something ..., the" name display')
oNameDisplay.set_inconsistent(False)
if self._oConfig.get_postfix_the_display():
oNameDisplay.set_active(True)
else:
oNameDisplay.set_active(False)
oNameDisplay.connect('activate', self.do_postfix_the_display)
oPrefsMenu.add(oNameDisplay)
oSaveOnExit = Gtk.CheckMenuItem(label='Save Pane Set on Exit')
oSaveOnExit.set_inconsistent(False)
if self._oConfig.get_save_on_exit():
oSaveOnExit.set_active(True)
else:
oSaveOnExit.set_active(False)
oSaveOnExit.connect('activate', self.do_toggle_save_on_exit)
oPrefsMenu.add(oSaveOnExit)
oSavePos = Gtk.CheckMenuItem(label='Save Exact Pane Positions')
oSavePos.set_inconsistent(False)
if self._oConfig.get_save_precise_pos():
oSavePos.set_active(True)
else:
oSavePos.set_active(False)
oSavePos.connect('activate', self.do_toggle_save_precise_pos)
oPrefsMenu.add(oSavePos)
oSaveWinSize = Gtk.CheckMenuItem(label='Save Window Size')
oSaveWinSize.set_inconsistent(False)
if self._oConfig.get_save_window_size():
oSaveWinSize.set_active(True)
else:
oSaveWinSize.set_active(False)
oSaveOnExit.connect('activate', self.do_toggle_save_window_size)
oPrefsMenu.add(oSaveWinSize)
def show_config_menu(self, widget):
notif = Gtk.CheckMenuItem(i18n.get('notificate'))
sound = Gtk.CheckMenuItem(i18n.get('sound'))
refresh = Gtk.MenuItem(i18n.get('manual_update'))
refresh.connect('activate', self.__refresh, self.column.id_)
self.menu = Gtk.Menu()
self.menu.append(sound)
self.menu.append(notif)
self.menu.append(refresh)
self.menu.show_all()
self.menu.popup(None, None, None, None, 0,
Gtk.get_current_event_time())
def _get_workflow_tool_submenu(callback, tool_id, position):
sub_menu = Gtk.Menu()
tool_active = (tool_id in editorpersistance.prefs.active_tools)
activity_item = Gtk.CheckMenuItem(_("Tool Active").encode('utf-8'))
activity_item.set_active(tool_active)
activity_item.connect("toggled", callback, (tool_id, "activity"))
activity_item.show()
sub_menu.add(activity_item)
guiutils.add_separetor(sub_menu)
position_item = Gtk.MenuItem.new_with_label(_("Set Position"))
if tool_active == False:
position_item.set_sensitive(False)
position_item.show()
position_menu = Gtk.Menu()
for i in range(1, len(editorpersistance.prefs.active_tools) + 1):
move_to_position_item = guiutils.get_menu_item(
str(i), _workflow_menu_callback, (tool_id, str(i)))
if i == position or position == -1:
move_to_position_item.set_sensitive(False)
move_to_position_item.show()
position_menu.add(move_to_position_item)
position_item.set_submenu(position_menu)
sub_menu.add(position_item)
return sub_menu
def addMenuAction(self, menu_name_id, act_name_id, act_name_string, is_check=False):
i = self.get_menu_index(menu_name_id)
if i < 0: return
menu_widget = self.menu_indexes[i][iMenuWidget]
if TrayEngine == "KDE":
act_widget = KAction(act_name_string, menu_widget)
act_widget.setCheckable(is_check)
menu_widget.addAction(act_widget)
elif TrayEngine == "AppIndicator":
menu_widget = menu_widget.get_submenu()
if is_check:
act_widget = Gtk.CheckMenuItem(act_name_string)
else:
act_widget = Gtk.ImageMenuItem(act_name_string)
act_widget.set_image(None)
act_widget.show()
menu_widget.append(act_widget)
elif TrayEngine == "Qt":
act_widget = QAction(act_name_string, menu_widget)
act_widget.setCheckable(is_check)
menu_widget.addAction(act_widget)
else:
act_widget = None
act_obj = [None, None, None, None]
act_obj[iActNameId] = act_name_id
act_obj[iActWidget] = act_widget
act_obj[iActParentMenuId] = menu_name_id
self.act_indexes.append(act_obj)
def PressHeader(widget, event):
if event.button != 3:
return False
columns = widget.get_parent().get_columns()
visible_columns = [column for column in columns if column.get_visible()]
one_visible_column = len(visible_columns) == 1
menu = gtk.Menu()
pos = 1
for column in columns:
title = column.get_title()
if title == "":
title = _("Column #%i") % pos
item = gtk.CheckMenuItem(title)
if column in visible_columns:
item.set_active(True)
if one_visible_column:
item.set_sensitive(False)
else:
item.set_active(False)
item.connect('activate', header_toggle, columns, pos - 1)
menu.append(item)
pos += 1
menu.show_all()
menu.attach_to_widget(widget.get_toplevel(), None)
menu.popup(None, None, None, None, event.button, event.time)
return True
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 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.MenuItem(_("Preferences"))
preferences_item.connect("activate", self.on_preferences_dialog)
preferences_item.show()
menu.append(preferences_item)
about_item = Gtk.MenuItem(_("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.MenuItem(_("Quit"))
image.connect("activate", self.quit)
image.show()
menu.append(image)
menu.show()
def checkitem(self, title, cb=None, active=False):
check_item = Gtk.CheckMenuItem(label=title)
check_item.set_active(active)
if cb:
check_item.connect("toggled", cb)
check_item.show()
return check_item
def on_populate_popup(self, view, menu):
menu.prepend(Gtk.SeparatorMenuItem())
def activate_linenumbers(item):
self.buffer.set_show_line_numbers(item.get_active())
item = Gtk.CheckMenuItem(_('Show Line Numbers'))
# T: preference option for sourceview plugin
item.set_active(self.buffer.object_attrib['linenumbers'])
item.set_sensitive(self.view.get_editable())
item.connect_after('activate', activate_linenumbers)
menu.prepend(item)
def activate_lang(item):
self.buffer.set_language(item.zim_sourceview_languageid)
item = Gtk.MenuItem.new_with_mnemonic(_('Syntax'))
item.set_sensitive(self.view.get_editable())
submenu = Gtk.Menu()
for lang in sorted(LANGUAGES, key=lambda k: k.lower()):
langitem = Gtk.MenuItem.new_with_mnemonic(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 __init__(self, songs, library, label=_("_Rating")):
super(RatingsMenuItem, self).__init__(label=label, use_underline=True)
self._songs = songs
image = Gtk.Image.new_from_icon_name(Icons.FAVORITE, Gtk.IconSize.MENU)
image.show()
self.set_image(image)
submenu = Gtk.Menu()
self.set_submenu(submenu)
self._rating_menu_items = []
for i in RATINGS.all:
text = "%0.2f\t%s" % (i, util.format_rating(i))
itm = Gtk.CheckMenuItem(label=text)
itm.rating = i
submenu.append(itm)
handler = itm.connect('toggled', self._on_rating_change, i,
library)
self._rating_menu_items.append((itm, handler))
reset = Gtk.MenuItem(label=_("_Remove Rating"), use_underline=True)
reset.connect('activate', self._on_rating_remove, library)
self._select_ratings()
submenu.append(SeparatorMenuItem())
submenu.append(reset)
submenu.show_all()
def _menuitem(self, label, icon, onclick, checked=None):
"""
Create a generic menu item.
:param str label: text
:param Gtk.Image icon: icon (may be ``None``)
:param onclick: onclick handler, either a callable or Gtk.Menu
:returns: the menu item object
:rtype: Gtk.MenuItem
"""
if checked is not None:
item = Gtk.CheckMenuItem()
item.set_active(checked)
elif icon is None:
item = Gtk.MenuItem()
else:
item = Gtk.ImageMenuItem()
item.set_image(icon)
# I don't really care for the "show icons only for nouns, not
# for verbs" policy:
item.set_always_show_image(True)
if label is not None:
item.set_label(label)
if isinstance(onclick, Gtk.Menu):
item.set_submenu(onclick)
elif onclick is not None:
item.connect('activate', onclick)
return item
def __init__(self, player):
super(VolumeMenu, self).__init__()
# ubuntu 12.04..
if hasattr(player, "bind_property"):
# Translators: player state, no action
item = Gtk.CheckMenuItem(label=_("_Mute"), use_underline=True)
player.bind_property("mute", item, "active",
GObject.BindingFlags.BIDIRECTIONAL)
self.append(item)
item.show()
item = Gtk.MenuItem(label=_("_Replay Gain Mode"), use_underline=True)
self.append(item)
item.show()
# Set replaygain mode as saved in configuration
replaygain_mode = config.gettext("player", "replaygain_mode", "auto")
self.__set_mode(player, replaygain_mode)
rg = Gtk.Menu()
rg.show()
item.set_submenu(rg)
item = None
for mode, title, profile in self.__modes:
item = RadioMenuItem(group=item, label=title,
use_underline=True)
rg.append(item)
item.connect("toggled", self.__changed, player, mode)
if replaygain_mode == mode:
item.set_active(True)
item.show()
def get_menu_item(self):
"""Overrides method from base class.
Adds the menu item on the MainWindow if the starters can be found.
"""
MessageBus.subscribe(MessageBus.Type.CARD_TEXT_MSG, 'post_set_text',
self.post_set_card_text)
# Listen for card set changes to manage the cache
listen_row_update(self.card_set_changed, PhysicalCardSet)
listen_row_destroy(self.card_set_added_deleted, PhysicalCardSet)
listen_row_created(self.card_set_added_deleted, PhysicalCardSet)
self._bDoSignalCleanup = True
# Make sure we add the tag we need
oCardTextView = self.parent.card_text_pane.view
oCardTextView.text_buffer.add_list_tag('starters')
self.oToggle = Gtk.CheckMenuItem(label="Show Starter Information")
self.oToggle.connect('toggled', self._toggle_starter)
self.oToggle.set_active(False)
if self.check_enabled():
sPrefsValue = self.get_config_item('show starters')
if sPrefsValue == 'Yes':
self.oToggle.set_active(True)
else:
self.oToggle.set_sensitive(False)
oDownload = Gtk.MenuItem(label="Download starter decks")
oDownload.connect('activate', self.do_download)
return [('Preferences', self.oToggle), ('Data Downloads', oDownload)]
def __init__(self):
self.statusIcon = gtk.StatusIcon()
pix = gdkpixbuf.Pixbuf.new_from_file_at_size("./masgor.svg",48,48)
self.statusIcon.set_from_pixbuf(pix)
self.statusIcon.set_visible(True)
self.statusIcon.set_tooltip_text("MASGOR")
self.menu = gtk.Menu()
self.Item = gtk.CheckMenuItem("Başlat",None)
self.Item.connect('activate', self.komut, self.statusIcon)
self.menu.append(self.Item)
self.Item1 = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES)
self.Item1.connect('activate', self.tercihler, self.statusIcon)
self.menu.append(self.Item1)
self.Item3 = gtk.ImageMenuItem(gtk.STOCK_ABOUT)
self.Item3.connect('activate', self.komut2, self.statusIcon)
self.menu.append(self.Item3)
self.Item2 = gtk.ImageMenuItem(gtk.STOCK_QUIT)
self.Item2.connect('activate', self.komut1, self.statusIcon)
self.menu.append(self.Item2)
self.menu.show_all()
self.statusIcon.connect('popup-menu', self.popup_menu_cb, self.menu)
self.statusIcon.set_visible(1)
def __init__(self):
self.ind = appindicator.Indicator.new(
"example-simple-client", "indicator-messages",
appindicator.IndicatorCategory.APPLICATION_STATUS)
self.ind.set_status(appindicator.IndicatorStatus.ACTIVE)
self.ind.set_attention_icon("indicator-messages-new")
self.ind.set_icon("distributor-logo")
# create a menu
self.menu = gtk.Menu()
# create items for the menu - labels, checkboxes, radio buttons and images are supported:
item = gtk.MenuItem(label="Regular Menu Item")
item.show()
self.menu.append(item)
check = gtk.CheckMenuItem(label="Check Menu Item")
check.show()
self.menu.append(check)
radio = gtk.RadioMenuItem(label="Radio Menu Item")
radio.show()
self.menu.append(radio)
image = gtk.ImageMenuItem(gtk.STOCK_QUIT)
image.connect("activate", self.quit)
image.show()
self.menu.append(image)
self.menu.show()
self.ind.set_menu(self.menu)
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 _setup_widgets(self):
self.set_main_item = Gtk.ImageMenuItem.new()
self.set_main_item.set_image(
Gtk.Image.new_from_icon_name(STOQ_CHECK, Gtk.IconSize.MENU))
self.set_main_item.set_label(_("Set as main image"))
self.set_internal_item = Gtk.CheckMenuItem(
label=_("Internal use only"))
self.view_item = Gtk.MenuItem(label=_("View"))
self.save_item = Gtk.MenuItem(label=_("Save"))
self.erase_item = Gtk.MenuItem(label=_("Remove"))
self.popmenu = Gtk.Menu()
for item, callback in [
(self.set_main_item, self._on_popup_set_main__activate),
(self.set_internal_item, self._on_popup_set_internal__activate),
(self.view_item, self._on_popup_view__activate),
(self.erase_item, self._on_popup_erase__activate),
(self.save_item, self._on_popup_save__activate)
]:
self.popmenu.append(item)
item.connect('activate', callback)
self.popmenu.show_all()
self._update_widgets()
if self.visual_mode:
self.image.set_sensitive(False)
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
def addAction(self, act_name_id, act_name_string, is_check=False):
if TrayEngine == "KDE":
act_widget = KAction(act_name_string, self.menu)
act_widget.setCheckable(is_check)
self.menu.addAction(act_widget)
elif TrayEngine == "AppIndicator":
if is_check:
act_widget = Gtk.CheckMenuItem(act_name_string)
else:
act_widget = Gtk.ImageMenuItem(act_name_string)
act_widget.set_image(None)
act_widget.show()
self.menu.append(act_widget)
elif TrayEngine == "Qt":
act_widget = QAction(act_name_string, self.menu)
act_widget.setCheckable(is_check)
self.menu.addAction(act_widget)
else:
act_widget = None
act_obj = [None, None, None, None]
act_obj[iActNameId] = act_name_id
act_obj[iActWidget] = act_widget
self.act_indexes.append(act_obj)
