def popup(treeview, event, view_id, target):
from blaplaylist import playlist_manager
from blaqueue import queue
if view_id == blaconst.VIEW_PLAYLISTS:
element = playlist_manager
elif view_id == blaconst.VIEW_QUEUE:
element = queue
accel_group = ui_manager.get_accel_group()
try:
path = treeview.get_path_at_pos(*map(int, [event.x, event.y]))[0]
except TypeError:
menu = gtk.Menu()
m = gtk.MenuItem("Paste")
mod, key = gtk.accelerator_parse("<Ctrl>V")
m.add_accelerator("activate", accel_group, mod, key, gtk.ACCEL_VISIBLE)
m.connect("activate", element.paste)
m.set_sensitive(bool(element.clipboard))
menu.append(m)
if view_id == blaconst.VIEW_QUEUE:
m = gtk.MenuItem("Clear queue")
m.connect("activate", lambda *x: element.clear())
menu.append(m)
menu.show_all()
menu.popup(None, None, None, event.button, event.time)
return
model, paths = treeview.get_selection().get_selected_rows()
item = model[path][0]
menu = gtk.Menu()
m = gtk.MenuItem("Play")
m.connect("activate", lambda *x: target.play_item(treeview, path))
menu.append(m)
menu.append(gtk.SeparatorMenuItem())
items = [
("Cut", element.cut, "<Ctrl>X", True),
("Copy", element.copy, "<Ctrl>C", True),
("Paste", element.paste, "<Ctrl>V", bool(element.clipboard)),
("Remove", element.remove, None, True)
]
for label, callback, accelerator, visibility in items:
m = gtk.MenuItem(label)
if accelerator:
mod, key = gtk.accelerator_parse(accelerator)
m.add_accelerator("activate", accel_group, mod, key,
gtk.ACCEL_VISIBLE)
m.connect("activate", callback)
m.set_sensitive(visibility)
menu.append(m)
menu.append(gtk.SeparatorMenuItem())
submenu = gtk.Menu()
items = [
("All", blaconst.SELECT_ALL),
("Complement", blaconst.SELECT_COMPLEMENT),
("By artist(s)", blaconst.SELECT_BY_ARTISTS),
("By album(s)", blaconst.SELECT_BY_ALBUMS),
("By album artist(s)", blaconst.SELECT_BY_ALBUM_ARTISTS),
("By genre(s)", blaconst.SELECT_BY_GENRES)
]
for label, type_ in items:
m = gtk.MenuItem(label)
m.connect("activate", lambda x, t=type_: element.select(t))
submenu.append(m)
m = gtk.MenuItem("Select")
m.set_submenu(submenu)
menu.append(m)
if view_id == blaconst.VIEW_PLAYLISTS:
# New playlist from...
submenu = gtk.Menu()
items = [
("Selection", blaconst.PLAYLIST_FROM_SELECTION),
("Selected artist(s)", blaconst.PLAYLIST_FROM_ARTISTS),
("Selected album(s)", blaconst.PLAYLIST_FROM_ALBUMS),
("Selected album artist(s)", blaconst.PLAYLIST_FROM_ALBUM_ARTISTS),
("Selected genre(s)", blaconst.PLAYLIST_FROM_GENRE)
]
for label, type_ in items:
m = gtk.MenuItem(label)
m.connect(
"activate",
lambda x, t=type_: playlist_manager.new_playlist_from_type(t))
submenu.append(m)
m = gtk.MenuItem("New playlist from")
m.set_submenu(submenu)
menu.append(m)
playlists = playlist_manager.get_playlists()
if len(playlists) > 1:
# Move to playlist
submenu = gtk.Menu()
current_playlist = playlist_manager.get_current_playlist()
for playlist in playlists:
if playlist == current_playlist:
continue
m = gtk.MenuItem(playlist.get_name())
m.connect("activate", lambda x, p=playlist:
target.add_selection_to_playlist(p, move=True))
submenu.append(m)
m = gtk.MenuItem("Move to playlist")
m.set_submenu(submenu)
menu.append(m)
# Add to playlist
submenu = gtk.Menu()
current_playlist = playlist_manager.get_current_playlist()
for playlist in playlists:
if playlist == current_playlist:
continue
m = gtk.MenuItem(playlist.get_name())
m.connect("activate", lambda x, p=playlist:
target.add_selection_to_playlist(p, move=False))
submenu.append(m)
m = gtk.MenuItem("Add to playlist")
m.set_submenu(submenu)
menu.append(m)
menu.append(gtk.SeparatorMenuItem())
# Remaining options
items = [
("Add to queue", "Q", lambda *x: target.send_to_queue()),
("Remove from queue", "R",
lambda *x: target.remove_from_queue(treeview)),
]
for label, accel, callback in items:
m = gtk.MenuItem(label)
mod, key = gtk.accelerator_parse(accel)
m.add_accelerator("activate", accel_group, mod, key,
gtk.ACCEL_VISIBLE)
m.connect("activate", callback)
menu.append(m)
menu.append(gtk.SeparatorMenuItem())
item = treeview.get_model()[path][0]
submenu = blafm.create_popup_menu(item.track)
if submenu:
m = gtk.MenuItem("last.fm")
m.set_submenu(submenu)
menu.append(m)
m = gtk.MenuItem("Open containing directory")
m.connect("activate",
lambda *x: blautil.open_directory(os.path.dirname(item.uri)))
menu.append(m)
menu.show_all()
menu.popup(None, None, None, event.button, event.time)
def __popup_menu(self, event):
model = self.get_model()
try:
path = self.get_path_at_pos(*map(int, [event.x, event.y]))[0]
except TypeError:
return
if self.__browser_id == blaconst.BROWSER_FILESYSTEM:
def dirname(s):
return s if os.path.isdir(s) else os.path.dirname(s)
resolve = True
else:
dirname = os.path.dirname
resolve = False
name = model[path][-1]
# TODO: Defer calling get_tracks() until it's actually needed, i.e.
# when an "activate" callback is invoked.
tracks = self.get_tracks()
directory = list(set(map(dirname, tracks)))
if len(directory) == 1 and os.path.isdir(directory[0]):
directory = directory[0]
else:
directory = None
items = [
("Send to current playlist", None,
lambda *x: playlist_manager.send_to_current_playlist(
tracks, resolve), True),
("Add to current playlist", None,
lambda *x: playlist_manager.add_to_current_playlist(
tracks, resolve), True),
("Send to new playlist", None,
lambda *x: playlist_manager.send_to_new_playlist(
tracks, name, resolve), True),
None,
("Open directory", None, lambda *x:
blautil.open_directory(directory), bool(directory)),
]
if self.__browser_id == blaconst.BROWSER_LIBRARY:
items.append(("Add to playback queue", "Q",
lambda *x: self.__send_to_queue(), True))
accel_group = blaplay.bla.ui_manager.get_accel_group()
menu = gtk.Menu()
for item in items:
if item is None:
m = gtk.SeparatorMenuItem()
else:
label, accel, callback, sensitive = item
m = gtk.MenuItem(label)
if accel is not None:
mod, key = gtk.accelerator_parse(accel)
m.add_accelerator("activate", accel_group, mod, key,
gtk.ACCEL_VISIBLE)
m.connect("activate", callback)
m.set_sensitive(sensitive)
menu.append(m)
menu.show_all()
menu.popup(None, None, None, event.button, event.time)
def __button_press_event(self, event):
def open_cover(*args):
blautil.open_with_filehandler(
self.__cover, "Failed to open image '%s'" % self.__cover)
def fetch_cover(*args):
BlaSidePane.fetcher.fetch_cover(
BlaSidePane.track, self.__update_timestamp(),
force_download=True)
def set_cover(*args):
diag = gtk.FileChooserDialog(
"Select cover",
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
diag.set_local_only(True)
response = diag.run()
path = diag.get_filename()
diag.destroy()
if response == gtk.RESPONSE_OK and path:
BlaSidePane.fetcher.set_cover(
self.__update_timestamp(), path)
def delete_cover(*args):
BlaSidePane.fetcher.set_cover(self.__update_timestamp())
# If the cover art display is used to display video delegate the
# button event to the default handler.
if (blacfg.getint("general", "view") != blaconst.VIEW_VIDEO and
player.video):
return False
if (event.button == 1 and event.type == gtk.gdk._2BUTTON_PRESS and
self.__cover != blaconst.COVER):
open_cover()
elif (event.button == 3 and
event.type not in [gtk.gdk._2BUTTON_PRESS,
gtk.gdk._3BUTTON_PRESS]):
menu = gtk.Menu()
sensitive = self.__cover != blaconst.COVER
items = [
("Open in image viewer", open_cover, sensitive),
("Open directory", lambda *x: blautil.open_directory(
os.path.dirname(self.__cover)), sensitive),
None,
("Fetch cover", fetch_cover, True),
("Set cover...",
lambda *x: set_cover(self.__update_timestamp()), True),
("Delete cover", delete_cover, sensitive)
]
track = BlaSidePane.track
if (player.get_state() == blaconst.STATE_STOPPED or
not track[ARTIST] or not track[ALBUM]):
state = False
else:
state = True
for item in items:
if not item:
m = gtk.SeparatorMenuItem()
else:
label, callback, sensitive = item
m = gtk.MenuItem(label)
m.connect("activate", callback)
m.set_sensitive(sensitive)
menu.append(m)
menu.show_all()
menu.popup(None, None, None, event.button, event.time)
return True
