def Menu(self, songs, songlist, library):
menu = SongsMenu(self.__librarian, songs, playlists=False, remove=True,
queue=False, devices=False, parent=self)
menu.prepend(SeparatorMenuItem())
in_fav = False
in_all = False
for song in songs:
if song in self.__fav_stations:
in_fav = True
elif song in self.__stations:
in_all = True
if in_fav and in_all:
break
button = MenuItem(_("Remove from Favorites"), Gtk.STOCK_REMOVE)
button.set_sensitive(in_fav)
gobject_weak(button.connect_object, 'activate',
self.__remove_fav, songs)
menu.prepend(button)
button = MenuItem(_("Add to Favorites"), Gtk.STOCK_ADD)
button.set_sensitive(in_all)
gobject_weak(button.connect_object, 'activate',
self.__add_fav, songs)
menu.prepend(button)
return menu
def Menu(self, songs, library, items):
in_fav = False
in_all = False
for song in songs:
if song in self.__fav_stations:
in_fav = True
elif song in self.__stations:
in_all = True
if in_fav and in_all:
break
iradio_items = []
button = MenuItem(_("Add to Favorites"), Icons.LIST_ADD)
button.set_sensitive(in_all)
connect_obj(button, 'activate', self.__add_fav, songs)
iradio_items.append(button)
button = MenuItem(_("Remove from Favorites"), Icons.LIST_REMOVE)
button.set_sensitive(in_fav)
connect_obj(button, 'activate', self.__remove_fav, songs)
iradio_items.append(button)
items.append(iradio_items)
menu = SongsMenu(self.__librarian,
songs,
playlists=False,
remove=True,
queue=False,
items=items)
return menu
def Menu(self, songs, songlist, library):
menu = SongsMenu(self.__librarian, songs, playlists=False, remove=True,
queue=False, accels=songlist.accelerators,
devices=False, parent=self)
menu.prepend(gtk.SeparatorMenuItem())
in_fav = False
in_all = False
for song in songs:
if song in self.__fav_stations:
in_fav = True
elif song in self.__stations:
in_all = True
if in_fav and in_all:
break
button = MenuItem(_("Remove from Favorites"), gtk.STOCK_REMOVE)
button.set_sensitive(in_fav)
gobject_weak(button.connect_object, 'activate',
self.__remove_fav, songs)
menu.prepend(button)
button = MenuItem(_("Add to Favorites"), gtk.STOCK_ADD)
button.set_sensitive(in_all)
gobject_weak(button.connect_object, 'activate',
self.__add_fav, songs)
menu.prepend(button)
return menu
def Menu(self, songs, library, items):
in_fav = False
in_all = False
for song in songs:
if song in self.__fav_stations:
in_fav = True
elif song in self.__stations:
in_all = True
if in_fav and in_all:
break
iradio_items = []
button = MenuItem(_("Add to Favorites"), Gtk.STOCK_ADD)
button.set_sensitive(in_all)
connect_obj(button, 'activate', self.__add_fav, songs)
iradio_items.append(button)
button = MenuItem(_("Remove from Favorites"), Gtk.STOCK_REMOVE)
button.set_sensitive(in_fav)
connect_obj(button, 'activate', self.__remove_fav, songs)
iradio_items.append(button)
items.append(iradio_items)
menu = SongsMenu(self.__librarian, songs, playlists=False, remove=True,
queue=False, devices=False, items=items)
return menu
def _init_submenu_items(self, menu, songs):
remove_item = MenuItem(_("_Remove all Images"), "edit-delete")
remove_item.connect('activate', self.__remove_images, songs)
remove_item.set_sensitive(any(song.has_images for song in songs))
menu.append(remove_item)
set_item = MenuItem(_("_Embed Current Image"), "edit-paste")
set_item.connect('activate', self.__set_image, songs)
menu.append(set_item)
menu.show_all()
return menu
def __popup_menu(self, view, library):
model, iter = view.get_selection().get_selected()
device = model[iter][0]
if device.is_connected() and not self.__busy:
songs = self.__list_songs(device)
else:
songs = []
menu = SongsMenu(library,
songs,
playlists=False,
devices=False,
remove=False)
menu.preseparate()
props = MenuItem(_("_Properties"), Icons.DOCUMENT_PROPERTIES)
connect_obj(props, 'activate', self.__properties, model[iter][0])
props.set_sensitive(not self.__busy)
menu.prepend(props)
ren = qltk.MenuItem(_("_Rename"), Icons.EDIT)
keyval, mod = Gtk.accelerator_parse("F2")
ren.add_accelerator('activate', self.accelerators, keyval, mod,
Gtk.AccelFlags.VISIBLE)
def rename(path):
self.__render.set_property('editable', True)
view.set_cursor(path, view.get_columns()[0], start_editing=True)
connect_obj(ren, 'activate', rename, model.get_path(iter))
menu.prepend(ren)
menu.preseparate()
eject = Gtk.ImageMenuItem(_("_Eject"), use_underline=True)
eject.set_image(
Gtk.Image.new_from_icon_name(Icons.MEDIA_EJECT, Gtk.IconSize.MENU))
eject.set_sensitive(not self.__busy and device.eject
and device.is_connected())
connect_obj(eject, 'activate', self.__eject, None)
menu.prepend(eject)
refresh = MenuItem(_("_Refresh"), Icons.VIEW_REFRESH)
refresh.set_sensitive(device.is_connected())
connect_obj(refresh, 'activate', self.__refresh, True)
menu.prepend(refresh)
menu.show_all()
return view.popup_menu(menu, 0, Gtk.get_current_event_time())
def __popup_menu(self, view, library):
model, iter = view.get_selection().get_selected()
device = model[iter][0]
if device.is_connected() and not self.__busy:
songs = self.__list_songs(device)
else:
songs = []
menu = SongsMenu(library, songs, playlists=False,
devices=False, remove=False)
menu.preseparate()
props = MenuItem(_("_Properties"), Icons.DOCUMENT_PROPERTIES)
connect_obj(props, 'activate', self.__properties, model[iter][0])
props.set_sensitive(not self.__busy)
menu.prepend(props)
ren = qltk.MenuItem(_("_Rename"), Icons.EDIT)
keyval, mod = Gtk.accelerator_parse("F2")
ren.add_accelerator(
'activate', self.accelerators, keyval, mod, Gtk.AccelFlags.VISIBLE)
def rename(path):
self.__render.set_property('editable', True)
view.set_cursor(path, view.get_columns()[0], start_editing=True)
connect_obj(ren, 'activate', rename, model.get_path(iter))
menu.prepend(ren)
menu.preseparate()
eject = Gtk.ImageMenuItem(_("_Eject"), use_underline=True)
eject.set_image(
Gtk.Image.new_from_icon_name(Icons.MEDIA_EJECT, Gtk.IconSize.MENU))
eject.set_sensitive(
not self.__busy and device.eject and device.is_connected())
connect_obj(eject, 'activate', self.__eject, None)
menu.prepend(eject)
refresh = MenuItem(_("_Refresh"), Icons.VIEW_REFRESH)
refresh.set_sensitive(device.is_connected())
connect_obj(refresh, 'activate', self.__refresh, True)
menu.prepend(refresh)
menu.show_all()
return view.popup_menu(menu, 0, Gtk.get_current_event_time())
def __popup(self, entry, menu):
undo = MenuItem(_("_Undo"), Icons.EDIT_UNDO)
add_fake_accel(undo, "<Primary>z")
redo = MenuItem(_("_Redo"), Icons.EDIT_REDO)
add_fake_accel(redo, "<Primary><shift>z")
sep = SeparatorMenuItem()
for widget in [sep, redo, undo]:
widget.show()
undo.connect("activate", lambda *x: self.undo())
redo.connect("activate", lambda *x: self.redo())
undo.set_sensitive(self.can_undo())
redo.set_sensitive(self.can_redo())
for item in [sep, redo, undo]:
menu.prepend(item)
def __popup(self, entry, menu):
undo = MenuItem(_("_Undo"), Icons.EDIT_UNDO)
add_fake_accel(undo, "<Primary>z")
redo = MenuItem(_("_Redo"), Icons.EDIT_REDO)
add_fake_accel(redo, "<Primary><shift>z")
sep = SeparatorMenuItem()
for widget in [sep, redo, undo]:
widget.show()
undo.connect('activate', lambda *x: self.undo())
redo.connect('activate', lambda *x: self.redo())
undo.set_sensitive(self.can_undo())
redo.set_sensitive(self.can_redo())
for item in [sep, redo, undo]:
menu.prepend(item)
def __popup_menu(self, view, parent):
menu = Gtk.Menu()
view.ensure_popup_selection()
model, rows = view.get_selection().get_selected_rows()
can_change = min([model[path][0].canedit for path in rows])
items = [
SplitDisc, SplitTitle, SplitPerformer, SplitArranger, SplitValues,
SplitPerformerFromTitle, SplitOriginalArtistFromTitle
]
items.extend(self.handler.plugins)
items.sort(key=lambda item: (item._order, item.__name__))
if len(rows) == 1:
row = model[rows[0]]
entry = row[0]
comment = entry.value
text = comment.text
split_menu = Gtk.Menu()
for Item in items:
if Item.tags and entry.tag not in Item.tags:
continue
try:
b = Item(entry.tag, text)
except:
util.print_exc()
else:
b.connect('activate', self.__menu_activate, view)
if (not min(
list(map(self.__songinfo.can_change, b.needs)) +
[1]) or comment.is_special()):
b.set_sensitive(False)
vals = b.activated(entry.tag, text)
if len(vals) > 1 and vals[1][1]:
split_menu.append(b)
if split_menu.get_children():
split_menu.append(SeparatorMenuItem())
pref_item = MenuItem(_("_Configure"), Icons.PREFERENCES_SYSTEM)
split_menu.append(pref_item)
def show_prefs(parent):
from quodlibet.qltk.exfalsowindow import ExFalsoWindow
if isinstance(app.window, ExFalsoWindow):
from quodlibet.qltk.exfalsowindow import PreferencesWindow
window = PreferencesWindow(parent)
else:
from quodlibet.qltk.prefs import PreferencesWindow
window = PreferencesWindow(parent, open_page="tagging")
window.show()
connect_obj(pref_item, "activate", show_prefs, self)
split_item = MenuItem(_("_Split Tag"), Icons.EDIT_FIND_REPLACE)
if split_menu.get_children():
split_item.set_submenu(split_menu)
else:
split_item.set_sensitive(False)
menu.append(split_item)
copy_b = MenuItem(_("_Copy Value(s)"), Icons.EDIT_COPY)
copy_b.connect('activate', self.__copy_tag_value, view)
qltk.add_fake_accel(copy_b, "<Primary>c")
menu.append(copy_b)
remove_b = MenuItem(_("_Remove"), Icons.LIST_REMOVE)
remove_b.connect('activate', self.__remove_tag, view)
qltk.add_fake_accel(remove_b, "Delete")
menu.append(remove_b)
menu.show_all()
# Setting the menu itself to be insensitive causes it to not
# be dismissed; see #473.
for c in menu.get_children():
c.set_sensitive(can_change and c.get_property('sensitive'))
copy_b.set_sensitive(True)
remove_b.set_sensitive(True)
menu.connect('selection-done', lambda m: m.destroy())
# XXX: Keep reference
self.__menu = menu
return view.popup_menu(menu, 3, Gtk.get_current_event_time())
class IndicatorMenu(Gtk.Menu):
__gsignals__ = {
'action-item-changed': (GObject.SignalFlags.RUN_LAST, None, tuple()),
}
def __init__(self, app, add_show_item=False):
super(IndicatorMenu, self).__init__()
self._app = app
player = app.player
show_item_bottom = is_plasma()
if add_show_item:
show_item = Gtk.CheckMenuItem.new_with_mnemonic(
_("_Show %(application-name)s") % {
"application-name": app.name})
def on_toggled(menuitem):
if menuitem.get_active():
app.present()
else:
app.hide()
pconfig.set("window_visible", menuitem.get_active())
self._toggle_id = show_item.connect("toggled", on_toggled)
def on_visible_changed(*args):
with show_item.handler_block(self._toggle_id):
show_item.set_active(app.window.get_visible())
connect_destroy(app.window, "notify::visible", on_visible_changed)
else:
show_item = None
self._play_item = MenuItem(_("_Play"), Icons.MEDIA_PLAYBACK_START)
self._play_item.connect("activate", self._on_play_pause, player)
self._play_item.set_no_show_all(True)
self._pause_item = MenuItem(_("P_ause"), Icons.MEDIA_PLAYBACK_PAUSE)
self._pause_item.connect("activate", self._on_play_pause, player)
self._pause_item.set_no_show_all(True)
self._action_item = None
previous = MenuItem(_("Pre_vious"), Icons.MEDIA_SKIP_BACKWARD)
previous.connect('activate', lambda *args: player.previous(force=True))
next = MenuItem(_("_Next"), Icons.MEDIA_SKIP_FORWARD)
next.connect('activate', lambda *args: player.next())
player_options = app.player_options
shuffle = Gtk.CheckMenuItem(label=_("_Shuffle"), use_underline=True)
player_options.bind_property("random", shuffle, "active",
GObject.BindingFlags.BIDIRECTIONAL)
player_options.notify("random")
repeat = Gtk.CheckMenuItem(label=_("_Repeat"), use_underline=True)
player_options.bind_property("repeat", repeat, "active",
GObject.BindingFlags.BIDIRECTIONAL)
player_options.notify("repeat")
safter = Gtk.CheckMenuItem(label=_("Stop _After This Song"),
use_underline=True)
player_options.bind_property("stop-after", safter, "active",
GObject.BindingFlags.BIDIRECTIONAL)
player_options.notify("stop-after")
browse = qltk.MenuItem(_("Open _Browser"), Icons.EDIT_FIND)
browse_sub = Gtk.Menu()
for Kind in browsers.browsers:
i = Gtk.MenuItem(label=Kind.accelerated_name, use_underline=True)
connect_obj(i,
'activate', LibraryBrowser.open, Kind, app.library, app.player)
browse_sub.append(i)
browse.set_submenu(browse_sub)
self._props = qltk.MenuItem(_("Edit _Tags"), Icons.DOCUMENT_PROPERTIES)
def on_properties(*args):
song = player.song
window = SongProperties(app.librarian, [song])
window.show()
self._props.connect('activate', on_properties)
self._info = MenuItem(_("_Information"), Icons.DIALOG_INFORMATION)
def on_information(*args):
song = player.song
window = Information(app.librarian, [song])
window.show()
self._info.connect('activate', on_information)
def set_rating(value):
song = player.song
song["~#rating"] = value
app.librarian.changed([song])
self._rating_item = rating = RatingsMenuItem([], app.library)
quit = MenuItem(_("_Quit"), Icons.APPLICATION_EXIT)
quit.connect('activate', lambda *x: app.quit())
if not show_item_bottom and show_item:
self.append(show_item)
self.append(SeparatorMenuItem())
self.append(self._play_item)
self.append(self._pause_item)
self.append(previous)
self.append(next)
self.append(SeparatorMenuItem())
self.append(shuffle)
self.append(repeat)
self.append(safter)
self.append(SeparatorMenuItem())
self.append(rating)
self.append(self._props)
self.append(self._info)
self.append(SeparatorMenuItem())
self.append(browse)
self.append(SeparatorMenuItem())
self.append(quit)
if show_item_bottom and show_item:
self.append(SeparatorMenuItem())
self.append(show_item)
self.show_all()
self.set_paused(True)
self.set_song(None)
def get_action_item(self):
"""Returns the 'Play' or 'Pause' action menu item (used for unity).
'action-item-changed' gets emitted if this changes.
"""
return self._action_item
def set_paused(self, paused):
"""Update the menu based on the player paused state"""
self._play_item.set_visible(paused)
self._pause_item.set_visible(not paused)
self._action_item = self._play_item if paused else self._pause_item
self.emit("action-item-changed")
def set_song(self, song):
"""Update the menu based on the passed song. Can be None.
This should be the persistent song and not a stream/info one.
"""
self._rating_item.set_sensitive(song is not None)
self._info.set_sensitive(song is not None)
self._props.set_sensitive(song is not None)
self._rating_item.set_songs([song])
def _on_play_pause(self, menuitem, player):
if player.song:
player.paused ^= True
else:
player.reset()
class IndicatorMenu(Gtk.Menu):
__gsignals__: GSignals = {
'action-item-changed': (GObject.SignalFlags.RUN_LAST, None, tuple()),
}
def __init__(self, app, add_show_item=False):
super().__init__()
self._app = app
player = app.player
show_item_bottom = is_plasma()
if add_show_item:
show_item = Gtk.CheckMenuItem.new_with_mnemonic(
_("_Show %(application-name)s") %
{"application-name": app.name})
def on_toggled(menuitem):
if menuitem.get_active():
app.present()
else:
app.hide()
self._toggle_id = show_item.connect("toggled", on_toggled)
def on_visible_changed(*args):
with show_item.handler_block(self._toggle_id):
show_item.set_active(app.window.get_visible())
connect_destroy(app.window, "notify::visible", on_visible_changed)
else:
show_item = None
self._play_item = MenuItem(_("_Play"), Icons.MEDIA_PLAYBACK_START)
self._play_item.connect("activate", self._on_play_pause, player)
self._play_item.set_no_show_all(True)
self._pause_item = MenuItem(_("P_ause"), Icons.MEDIA_PLAYBACK_PAUSE)
self._pause_item.connect("activate", self._on_play_pause, player)
self._pause_item.set_no_show_all(True)
self._action_item = None
previous = MenuItem(_("Pre_vious"), Icons.MEDIA_SKIP_BACKWARD)
previous.connect('activate', lambda *args: player.previous(force=True))
next = MenuItem(_("_Next"), Icons.MEDIA_SKIP_FORWARD)
next.connect('activate', lambda *args: player.next())
player_options = app.player_options
shuffle = Gtk.CheckMenuItem(label=_("_Shuffle"), use_underline=True)
player_options.bind_property("shuffle", shuffle, "active",
GObject.BindingFlags.BIDIRECTIONAL)
player_options.notify("shuffle")
repeat = Gtk.CheckMenuItem(label=_("_Repeat"), use_underline=True)
player_options.bind_property("repeat", repeat, "active",
GObject.BindingFlags.BIDIRECTIONAL)
player_options.notify("repeat")
safter = Gtk.CheckMenuItem(label=_("Stop _After This Song"),
use_underline=True)
player_options.bind_property("stop-after", safter, "active",
GObject.BindingFlags.BIDIRECTIONAL)
player_options.notify("stop-after")
browse = qltk.MenuItem(_("Open _Browser"), Icons.EDIT_FIND)
browse_sub = Gtk.Menu()
for Kind in browsers.browsers:
i = Gtk.MenuItem(label=Kind.accelerated_name, use_underline=True)
connect_obj(i, 'activate', LibraryBrowser.open, Kind, app.library,
app.player)
browse_sub.append(i)
browse.set_submenu(browse_sub)
self._props = qltk.MenuItem(_("Edit _Tags"), Icons.EDIT)
def on_properties(*args):
song = player.song
window = SongProperties(app.librarian, [song])
window.show()
self._props.connect('activate', on_properties)
self._info = MenuItem(_("_Information"), Icons.DIALOG_INFORMATION)
self._playlists_item = MenuItem(_("Play_lists"),
Icons.FOLDER_DRAG_ACCEPT)
self._new_playlist_submenu_for(player.song)
def on_information(*args):
song = player.song
window = Information(app.librarian, [song])
window.show()
self._info.connect('activate', on_information)
def set_rating(value):
song = player.song
song["~#rating"] = value
app.librarian.changed([song])
self._rating_item = rating = RatingsMenuItem([], app.library)
quit = MenuItem(_("_Quit"), Icons.APPLICATION_EXIT)
quit.connect('activate', lambda *x: app.quit())
if not show_item_bottom and show_item:
self.append(show_item)
self.append(SeparatorMenuItem())
self.append(self._play_item)
self.append(self._pause_item)
self.append(previous)
self.append(next)
self.append(SeparatorMenuItem())
self.append(shuffle)
self.append(repeat)
self.append(safter)
self.append(SeparatorMenuItem())
self.append(rating)
self.append(self._playlists_item)
self.append(self._props)
self.append(self._info)
self.append(SeparatorMenuItem())
self.append(browse)
self.append(SeparatorMenuItem())
self.append(quit)
if show_item_bottom and show_item:
self.append(SeparatorMenuItem())
self.append(show_item)
self.show_all()
self.set_paused(True)
self.set_song(None)
def get_action_item(self):
"""Returns the 'Play' or 'Pause' action menu item (used for unity).
'action-item-changed' gets emitted if this changes.
"""
return self._action_item
def set_paused(self, paused):
"""Update the menu based on the player paused state"""
self._play_item.set_visible(paused)
self._pause_item.set_visible(not paused)
self._action_item = self._play_item if paused else self._pause_item
self.emit("action-item-changed")
def set_song(self, song):
"""Update the menu based on the passed song. Can be None.
This should be the persistent song and not a stream/info one.
"""
self._rating_item.set_sensitive(song is not None)
self._info.set_sensitive(song is not None)
self._props.set_sensitive(song is not None)
self._rating_item.set_songs([song])
self._new_playlist_submenu_for(song)
def _new_playlist_submenu_for(self, song):
submenu = self._playlists_item.get_submenu()
if submenu:
submenu.destroy()
playlist_menu = PlaylistMenu([song], PlaylistsBrowser.playlists())
def on_new(widget, playlist):
PlaylistsBrowser.changed(playlist)
playlist_menu.connect('new', on_new)
self._playlists_item.set_submenu(playlist_menu)
self._playlists_item.set_sensitive(bool(song) and song.can_add)
self._playlists_item.show_all()
def _on_play_pause(self, menuitem, player):
player.playpause()
def __popup_menu(self, view, parent):
menu = Gtk.Menu()
view.ensure_popup_selection()
model, rows = view.get_selection().get_selected_rows()
can_change = min([model[path][0].canedit for path in rows])
items = [SplitDisc, SplitTitle, SplitPerformer, SplitArranger,
SplitValues, SplitPerformerFromTitle,
SplitOriginalArtistFromTitle]
items.extend(self.handler.plugins)
items.sort(key=lambda item: (item._order, item.__name__))
if len(rows) == 1:
row = model[rows[0]]
entry = row[0]
comment = entry.value
text = comment.text
for Item in items:
if Item.tags and entry.tag not in Item.tags:
continue
try:
b = Item(entry.tag, text)
except:
util.print_exc()
else:
b.connect('activate', self.__menu_activate, view)
if (not min(listmap(self.__songinfo.can_change, b.needs) +
[1])
or comment.is_special()):
b.set_sensitive(False)
menu.append(b)
if menu.get_children():
menu.append(SeparatorMenuItem())
copy_b = MenuItem(_("_Copy Value(s)"), Icons.EDIT_COPY)
copy_b.connect('activate', self.__copy_tag_value, view)
qltk.add_fake_accel(copy_b, "<Primary>c")
menu.append(copy_b)
remove_b = MenuItem(_("_Remove"), Icons.LIST_REMOVE)
remove_b.connect('activate', self.__remove_tag, view)
qltk.add_fake_accel(remove_b, "Delete")
menu.append(remove_b)
menu.show_all()
# Setting the menu itself to be insensitive causes it to not
# be dismissed; see #473.
for c in menu.get_children():
c.set_sensitive(can_change and c.get_property('sensitive'))
copy_b.set_sensitive(True)
remove_b.set_sensitive(True)
menu.connect('selection-done', lambda m: m.destroy())
# XXX: Keep reference
self.__menu = menu
return view.popup_menu(menu, 3, Gtk.get_current_event_time())
def __popup_menu(self, view, parent):
menu = Gtk.Menu()
view.ensure_popup_selection()
model, rows = view.get_selection().get_selected_rows()
can_change = min([model[path][0].canedit for path in rows])
items = [
SplitDisc, SplitTitle, SplitPerformer, SplitArranger, SplitValues,
SplitPerformerFromTitle, SplitOriginalArtistFromTitle
]
items.extend(self.handler.plugins)
items.sort(key=lambda item: (item._order, item.__name__))
if len(rows) == 1:
row = model[rows[0]]
entry = row[0]
comment = entry.value
text = comment.text
for Item in items:
if Item.tags and entry.tag not in Item.tags:
continue
try:
b = Item(entry.tag, text)
except:
util.print_exc()
else:
b.connect('activate', self.__menu_activate, view)
if (not min(
list(map(self.__songinfo.can_change, b.needs)) +
[1]) or comment.is_special()):
b.set_sensitive(False)
menu.append(b)
if menu.get_children():
menu.append(SeparatorMenuItem())
copy_b = MenuItem(_("_Copy Value(s)"), Icons.EDIT_COPY)
copy_b.connect('activate', self.__copy_tag_value, view)
qltk.add_fake_accel(copy_b, "<Primary>c")
menu.append(copy_b)
remove_b = MenuItem(_("_Remove"), Icons.LIST_REMOVE)
remove_b.connect('activate', self.__remove_tag, view)
qltk.add_fake_accel(remove_b, "Delete")
menu.append(remove_b)
menu.show_all()
# Setting the menu itself to be insensitive causes it to not
# be dismissed; see #473.
for c in menu.get_children():
c.set_sensitive(can_change and c.get_property('sensitive'))
copy_b.set_sensitive(True)
remove_b.set_sensitive(True)
menu.connect('selection-done', lambda m: m.destroy())
# XXX: Keep reference
self.__menu = menu
return view.popup_menu(menu, 3, Gtk.get_current_event_time())
def _popup_menu(self, view: BaseView, _parent):
menu = Gtk.Menu()
view.ensure_popup_selection()
model, rows = view.get_selection().get_selected_rows()
can_change = all(model[path][0].canedit for path in rows)
if len(rows) == 1:
row = model[rows[0]]
entry = row[0]
comment = entry.value
text = comment.text
split_menu = Gtk.Menu()
for Item in self._SPLITTERS:
if Item.tags and entry.tag not in Item.tags:
continue
item = self.__item_for(view, Item, entry.tag, text)
if not item:
continue
vals = item.activated(entry.tag, text)
changeable = any(not self._group_info.can_change(k)
for k in item.needs)
fixed = changeable or comment.is_special()
if fixed:
item.set_sensitive(False)
if len(vals) > 1 and vals[1][1]:
split_menu.append(item)
if split_menu.get_children():
split_menu.append(SeparatorMenuItem())
plugins = self.handler.plugins
print_d(f"Adding {len(plugins)} plugin(s) to menu: "
f"{', '.join(p.__name__ for p in plugins)}")
for p_cls in plugins:
item = self.__item_for(view, p_cls, entry.tag, text)
if not item:
continue
results = item.activated(entry.tag, text)
# Only enable for the user if the plugin would do something
item.set_sensitive(results != [(entry.tag, text)])
menu.append(item)
pref_item = MenuItem(_("_Configure"), Icons.PREFERENCES_SYSTEM)
split_menu.append(pref_item)
def show_prefs(parent):
from quodlibet.qltk.exfalsowindow import ExFalsoWindow
if isinstance(app.window, ExFalsoWindow):
from quodlibet.qltk.exfalsowindow import PreferencesWindow
window = PreferencesWindow(parent)
else:
from quodlibet.qltk.prefs import PreferencesWindow
window = PreferencesWindow(parent, open_page="tagging")
window.show()
connect_obj(pref_item, "activate", show_prefs, self)
split_item = MenuItem(_("_Split Tag"), Icons.EDIT_FIND_REPLACE)
if split_menu.get_children():
split_item.set_submenu(split_menu)
else:
split_item.set_sensitive(False)
menu.append(split_item)
copy_b = MenuItem(_("_Copy Value(s)"), Icons.EDIT_COPY)
copy_b.connect('activate', self.__copy_tag_value, view)
qltk.add_fake_accel(copy_b, "<Primary>c")
menu.append(copy_b)
remove_b = MenuItem(_("_Remove"), Icons.LIST_REMOVE)
remove_b.connect('activate', self.__remove_tag, view)
qltk.add_fake_accel(remove_b, "Delete")
menu.append(remove_b)
menu.show_all()
# Setting the menu itself to be insensitive causes it to not
# be dismissed; see #473.
for c in menu.get_children():
c.set_sensitive(can_change and c.get_property('sensitive'))
copy_b.set_sensitive(True)
remove_b.set_sensitive(True)
menu.connect('selection-done', lambda m: m.destroy())
# XXX: Keep reference
self.__menu = menu
return view.popup_menu(menu, 3, Gtk.get_current_event_time())