class TQueueExpander(TestCase):
def setUp(self):
quodlibet.config.init()
player = NullPlayer()
self.queue = QueueExpander(SongLibrary(), player)
def test_ctr(self):
pass
def test_status_icon(self):
widget = PlaybackStatusIcon()
widget.play()
widget.stop()
widget.pause()
widget.pause()
def test_random_at_startup(self):
self.failIf(isinstance(self.queue.model.order, OrderShuffle))
quodlibet.config.set("memory", "shufflequeue", True)
self.queue = self.queue = QueueExpander(SongLibrary(), NullPlayer())
# See issue #2411
self.failUnless(isinstance(self.queue.model.order, OrderShuffle))
def tearDown(self):
self.queue.destroy()
quodlibet.config.quit()
class TQueueExpander(TestCase):
def setUp(self):
quodlibet.config.init()
player = NullPlayer()
self.queue = QueueExpander(SongLibrary(), player)
def test_ctr(self):
pass
def test_status_icon(self):
widget = PlaybackStatusIcon()
widget.play()
widget.stop()
widget.pause()
widget.pause()
def test_random_at_startup(self):
self.failIf(isinstance(self.queue.model.order, OrderShuffle))
quodlibet.config.set("memory", "shufflequeue", True)
self.queue = self.queue = QueueExpander(SongLibrary(), NullPlayer())
# See issue #2411
self.failUnless(isinstance(self.queue.model.order, OrderShuffle))
def tearDown(self):
self.queue.destroy()
quodlibet.config.quit()
class TQueueExpander(TestCase):
def setUp(self):
quodlibet.config.init()
player = NullPlayer()
self.queue = QueueExpander(Gtk.CheckMenuItem(), SongLibrary(), player)
def test_ctr(self):
pass
def tearDown(self):
self.queue.destroy()
quodlibet.config.quit()
class TQueueExpander(TestCase):
def setUp(self):
quodlibet.config.init()
player = NullPlayer()
self.queue = QueueExpander(gtk.CheckMenuItem(), SongLibrary(), player)
def test_ctr(self):
pass
def tearDown(self):
self.queue.destroy()
quodlibet.config.quit()
class TQueueExpander(TestCase):
def setUp(self):
quodlibet.config.init()
player = NullPlayer()
self.queue = QueueExpander(Gtk.CheckMenuItem(), SongLibrary(), player)
def test_ctr(self):
pass
def test_status_icon(self):
widget = PlaybackStatusIcon()
widget.play()
widget.stop()
widget.pause()
widget.pause()
def tearDown(self):
self.queue.destroy()
quodlibet.config.quit()
def __init__(self, library, player):
super(QuodLibetWindow, self).__init__()
self.last_dir = const.HOME
self.__update_title(player)
self.set_default_size(550, 450)
main_box = gtk.VBox()
self.add(main_box)
# create test instance of the MPD backend
self._mpd = quodmpd.QuodMpd()
# create main menubar, load/restore accelerator groups
self.__library = library
self.__create_menu(player, library)
self.add_accel_group(self.ui.get_accel_group())
accel_fn = os.path.join(const.USERDIR, "accels")
gtk.accel_map_load(accel_fn)
accelgroup = gtk.accel_groups_from_object(self)[0]
accelgroup.connect('accel-changed',
lambda *args: gtk.accel_map_save(accel_fn))
main_box.pack_start(self.ui.get_widget("/Menu"), expand=False)
# get the playlist up before other stuff
self.songlist = MainSongList(library, player)
self.songlist.show_all()
self.add_accel_group(self.songlist.accelerators)
self.songlist.connect_after(
'drag-data-received', self.__songlist_drag_data_recv)
self.song_scroller = SongListScroller(
self.ui.get_widget("/Menu/View/SongList"))
self.song_scroller.add(self.songlist)
self.qexpander = QueueExpander(
self.ui.get_widget("/Menu/View/Queue"), library, player)
self.playlist = PlaylistMux(
player, self.qexpander.model, self.songlist.model)
top_bar = TopBar(self, player, library)
top_align = Alignment(top_bar, border=3, bottom=-3)
main_box.pack_start(top_align, expand=False)
self.__browserbox = Alignment(top=3, bottom=3)
main_box.pack_start(self.__browserbox)
statusbox = StatusBarBox(self.songlist.model, player)
self.order = statusbox.order
self.repeat = statusbox.repeat
self.statusbar = statusbox.statusbar
main_box.pack_start(Alignment(statusbox, border=3, top=-3),
expand=False)
self.songpane = gtk.VPaned()
self.songpane.pack1(self.song_scroller, resize=True, shrink=False)
self.songpane.pack2(self.qexpander, resize=True, shrink=False)
self.__handle_position = self.songpane.get_property("position")
self.song_scroller.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::expanded', self.__expand_or)
self.qexpander.connect('size-allocate', self.__qex_size_allocate)
self.songpane.connect('notify', self.__moved_pane_handle)
sort = config.get('memory', 'sortby')
self.songlist.set_sort_by(None, sort[1:], order=int(sort[0]))
self.browser = None
main_box.show_all()
try:
self.select_browser(
self, config.get("memory", "browser"), library, player, True)
except:
config.set("memory", "browser", browsers.name(0))
config.save(const.CONFIG)
raise
# set at least the playlist before the mainloop starts..
player.setup(self.playlist, None, 0)
def delayed_song_set():
song = library.get(config.get("memory", "song"))
seek_pos = config.getint("memory", "seek")
config.set("memory", "seek", 0)
player.setup(self.playlist, song, seek_pos)
gobject.idle_add(delayed_song_set)
self.showhide_playlist(self.ui.get_widget("/Menu/View/SongList"))
self.showhide_playqueue(self.ui.get_widget("/Menu/View/Queue"))
self.songlist.connect('popup-menu', self.__songs_popup_menu)
self.songlist.connect('columns-changed', self.__cols_changed)
self.songlist.connect('columns-changed', self.__hide_headers)
self.songlist.get_selection().connect(
'changed', util.DeferredSignal(self.__set_time))
lib = library.librarian
gobject_weak(lib.connect, 'removed', self.__set_time, parent=self)
gobject_weak(lib.connect, 'added', self.__set_time, parent=self)
gobject_weak(lib.connect_object, 'changed', self.__song_changed,
player, parent=self)
player_sigs = [
('song-ended', self.__song_ended),
('song-started', self.__song_started),
('paused', self.__update_paused, True),
('unpaused', self.__update_paused, False),
]
for sig in player_sigs:
gobject_weak(player.connect, *sig, **{"parent": self})
targets = [("text/uri-list", 0, 1)]
self.drag_dest_set(
gtk.DEST_DEFAULT_ALL, targets, gtk.gdk.ACTION_DEFAULT)
self.connect_object('drag-motion', QuodLibetWindow.__drag_motion, self)
self.connect_object('drag-leave', QuodLibetWindow.__drag_leave, self)
self.connect_object(
'drag-data-received', QuodLibetWindow.__drag_data_received, self)
if config.getboolean('library', 'refresh_on_start'):
self.__rebuild(None, False)
self.connect_object("key-press-event", self.__key_pressed, player)
self.connect("delete-event", self.__save_browser)
self.connect("destroy", self.__destroy)
self.enable_window_tracking("quodlibet")
def __init__(self, library, player, headless=False):
super(QuodLibetWindow, self).__init__(dialog=False)
self.last_dir = const.HOME
self.__update_title(player)
self.set_default_size(550, 450)
main_box = Gtk.VBox()
self.add(main_box)
# create main menubar, load/restore accelerator groups
self.__library = library
ui = self.__create_menu(player, library)
accel_group = ui.get_accel_group()
self.add_accel_group(accel_group)
# dbus app menu
AppMenu(self, ui.get_action_groups()[0])
accel_fn = os.path.join(const.USERDIR, "accels")
Gtk.AccelMap.load(accel_fn)
def accel_save_cb(*args):
Gtk.AccelMap.save(accel_fn)
accel_group.connect_object('accel-changed', accel_save_cb, None)
main_box.pack_start(ui.get_widget("/Menu"), False, True, 0)
# get the playlist up before other stuff
self.songlist = MainSongList(library, player)
self.songlist.show_all()
self.songlist.connect_after(
'drag-data-received', self.__songlist_drag_data_recv)
self.song_scroller = SongListScroller(
ui.get_widget("/Menu/View/SongList"))
self.song_scroller.add(self.songlist)
self.qexpander = QueueExpander(
ui.get_widget("/Menu/View/Queue"), library, player)
self.playlist = PlaylistMux(
player, self.qexpander.model, self.songlist.model)
top_bar = TopBar(self, player, library)
main_box.pack_start(top_bar, False, True, 0)
self.top_bar = top_bar
self.__browserbox = Alignment(bottom=3)
main_box.pack_start(self.__browserbox, True, True, 0)
statusbox = StatusBarBox(self.songlist.model, player)
self.order = statusbox.order
self.repeat = statusbox.repeat
self.statusbar = statusbox.statusbar
main_box.pack_start(
Alignment(statusbox, border=3, top=-3, right=3),
False, True, 0)
self.songpane = ConfigRVPaned("memory", "queue_position", 0.75)
self.songpane.pack1(self.song_scroller, resize=True, shrink=False)
self.songpane.pack2(self.qexpander, resize=True, shrink=False)
self.__handle_position = self.songpane.get_property("position")
def songpane_button_press_cb(pane, event):
"""If we start to drag the pane handle while the
queue expander is unexpanded, expand it and move the handle
to the bottom, so we can 'drag' the queue out
"""
if event.window != pane.get_handle_window():
return False
if not self.qexpander.get_expanded():
self.qexpander.set_expanded(True)
pane.set_relative(1.0)
return False
self.songpane.connect("button-press-event", songpane_button_press_cb)
self.song_scroller.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::expanded', self.__expand_or)
self.qexpander.connect('draw', self.__qex_size_allocate)
self.songpane.connect('notify', self.__moved_pane_handle)
try:
orders = []
for e in config.getstringlist('memory', 'sortby', []):
orders.append((e[1:], int(e[0])))
except ValueError:
pass
else:
self.songlist.set_sort_orders(orders)
self.browser = None
self.ui = ui
main_box.show_all()
try:
self.select_browser(
self, config.get("memory", "browser"), library, player, True)
except:
config.set("memory", "browser", browsers.name(0))
config.save(const.CONFIG)
raise
# set at least the playlist before the mainloop starts..
player.setup(self.playlist, None, 0)
def delayed_song_set():
self.__delayed_setup = None
song = library.get(config.get("memory", "song"))
seek_pos = config.getint("memory", "seek", 0)
config.set("memory", "seek", 0)
player.setup(self.playlist, song, seek_pos)
self.__delayed_setup = GLib.idle_add(delayed_song_set)
self.showhide_playlist(ui.get_widget("/Menu/View/SongList"))
self.showhide_playqueue(ui.get_widget("/Menu/View/Queue"))
self.songlist.connect('popup-menu', self.__songs_popup_menu)
self.songlist.connect('columns-changed', self.__cols_changed)
self.songlist.connect('columns-changed', self.__hide_headers)
self.songlist.info.connect("changed", self.__set_time)
lib = library.librarian
gobject_weak(lib.connect_object, 'changed', self.__song_changed,
player, parent=self)
self._playback_error_dialog = None
player_sigs = [
('song-started', self.__song_started),
('paused', self.__update_paused, True),
('unpaused', self.__update_paused, False),
]
for sig in player_sigs:
gobject_weak(player.connect, *sig, **{"parent": self})
# make sure we redraw all error indicators before opening
# a dialog (blocking the main loop), so connect after default handlers
gobject_weak(player.connect_after, 'error',
self.__player_error, **{"parent": self})
# connect after to let SongTracker update stats
player_sigs.append(
gobject_weak(player.connect_after, "song-ended",
self.__song_ended, parent=self))
targets = [("text/uri-list", Gtk.TargetFlags.OTHER_APP, DND_URI_LIST)]
targets = [Gtk.TargetEntry.new(*t) for t in targets]
self.drag_dest_set(
Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY)
self.connect('drag-data-received', self.__drag_data_received)
if not headless:
GLib.idle_add(self.__configure_scan_dirs, library)
if config.getboolean('library', 'refresh_on_start'):
self.__rebuild(None, False)
self.connect_object("key-press-event", self.__key_pressed, player)
self.connect("delete-event", self.__save_browser)
self.connect("destroy", self.__destroy)
self.enable_window_tracking("quodlibet")
class QuodLibetWindow(gtk.Window, PersistentWindowMixin):
SIG_PYOBJECT = (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (object,))
__gsignals__ = {
'artwork-changed': SIG_PYOBJECT,
}
def __init__(self, library, player):
super(QuodLibetWindow, self).__init__()
self.last_dir = const.HOME
self.__update_title(player)
self.set_default_size(550, 450)
main_box = gtk.VBox()
self.add(main_box)
# create test instance of the MPD backend
self._mpd = quodmpd.QuodMpd()
# create main menubar, load/restore accelerator groups
self.__library = library
self.__create_menu(player, library)
self.add_accel_group(self.ui.get_accel_group())
accel_fn = os.path.join(const.USERDIR, "accels")
gtk.accel_map_load(accel_fn)
accelgroup = gtk.accel_groups_from_object(self)[0]
accelgroup.connect('accel-changed',
lambda *args: gtk.accel_map_save(accel_fn))
main_box.pack_start(self.ui.get_widget("/Menu"), expand=False)
# get the playlist up before other stuff
self.songlist = MainSongList(library, player)
self.songlist.show_all()
self.add_accel_group(self.songlist.accelerators)
self.songlist.connect_after(
'drag-data-received', self.__songlist_drag_data_recv)
self.song_scroller = SongListScroller(
self.ui.get_widget("/Menu/View/SongList"))
self.song_scroller.add(self.songlist)
self.qexpander = QueueExpander(
self.ui.get_widget("/Menu/View/Queue"), library, player)
self.playlist = PlaylistMux(
player, self.qexpander.model, self.songlist.model)
top_bar = TopBar(self, player, library)
top_align = Alignment(top_bar, border=3, bottom=-3)
main_box.pack_start(top_align, expand=False)
self.__browserbox = Alignment(top=3, bottom=3)
main_box.pack_start(self.__browserbox)
statusbox = StatusBarBox(self.songlist.model, player)
self.order = statusbox.order
self.repeat = statusbox.repeat
self.statusbar = statusbox.statusbar
main_box.pack_start(Alignment(statusbox, border=3, top=-3),
expand=False)
self.songpane = gtk.VPaned()
self.songpane.pack1(self.song_scroller, resize=True, shrink=False)
self.songpane.pack2(self.qexpander, resize=True, shrink=False)
self.__handle_position = self.songpane.get_property("position")
self.song_scroller.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::expanded', self.__expand_or)
self.qexpander.connect('size-allocate', self.__qex_size_allocate)
self.songpane.connect('notify', self.__moved_pane_handle)
sort = config.get('memory', 'sortby')
self.songlist.set_sort_by(None, sort[1:], order=int(sort[0]))
self.browser = None
main_box.show_all()
try:
self.select_browser(
self, config.get("memory", "browser"), library, player, True)
except:
config.set("memory", "browser", browsers.name(0))
config.save(const.CONFIG)
raise
# set at least the playlist before the mainloop starts..
player.setup(self.playlist, None, 0)
def delayed_song_set():
song = library.get(config.get("memory", "song"))
seek_pos = config.getint("memory", "seek")
config.set("memory", "seek", 0)
player.setup(self.playlist, song, seek_pos)
gobject.idle_add(delayed_song_set)
self.showhide_playlist(self.ui.get_widget("/Menu/View/SongList"))
self.showhide_playqueue(self.ui.get_widget("/Menu/View/Queue"))
self.songlist.connect('popup-menu', self.__songs_popup_menu)
self.songlist.connect('columns-changed', self.__cols_changed)
self.songlist.connect('columns-changed', self.__hide_headers)
self.songlist.get_selection().connect(
'changed', util.DeferredSignal(self.__set_time))
lib = library.librarian
gobject_weak(lib.connect, 'removed', self.__set_time, parent=self)
gobject_weak(lib.connect, 'added', self.__set_time, parent=self)
gobject_weak(lib.connect_object, 'changed', self.__song_changed,
player, parent=self)
player_sigs = [
('song-ended', self.__song_ended),
('song-started', self.__song_started),
('paused', self.__update_paused, True),
('unpaused', self.__update_paused, False),
]
for sig in player_sigs:
gobject_weak(player.connect, *sig, **{"parent": self})
targets = [("text/uri-list", 0, 1)]
self.drag_dest_set(
gtk.DEST_DEFAULT_ALL, targets, gtk.gdk.ACTION_DEFAULT)
self.connect_object('drag-motion', QuodLibetWindow.__drag_motion, self)
self.connect_object('drag-leave', QuodLibetWindow.__drag_leave, self)
self.connect_object(
'drag-data-received', QuodLibetWindow.__drag_data_received, self)
if config.getboolean('library', 'refresh_on_start'):
self.__rebuild(None, False)
self.connect_object("key-press-event", self.__key_pressed, player)
self.connect("delete-event", self.__save_browser)
self.connect("destroy", self.__destroy)
self.enable_window_tracking("quodlibet")
def __key_pressed(self, player, event):
if not player.song:
return
def seek_relative(seconds):
current = player.get_position()
current += seconds * 1000
current = min(player.song("~#length") * 1000 -1, current)
current = max(0, current)
player.seek(current)
if qltk.is_accel(event, "<alt>Right"):
seek_relative(10)
return True
elif qltk.is_accel(event, "<alt>Left"):
seek_relative(-10)
return True
def __destroy(self, *args):
# The tray icon plugin tries to unhide QL because it gets disabled
# on Ql exit. The window should stay hidden after destroy.
self.show = lambda: None
self.present = self.show
def __drag_motion(self, ctx, x, y, time):
# Don't accept drops from QL itself, since it offers text/uri-list.
if ctx.get_source_widget() is None:
self.drag_highlight()
return True
else: return False
def __drag_leave(self, ctx, time):
self.drag_unhighlight()
def __drag_data_received(self, ctx, x, y, sel, tid, etime):
if tid == 1: uris = sel.get_uris()
if tid == 2:
uri = sel.data.decode('utf16', 'replace').split('\n')[0]
uris = [uri.encode('ascii', 'replace')]
dirs = []
error = False
for uri in uris:
try: uri = URI(uri)
except ValueError: continue
if uri.is_filename:
loc = os.path.normpath(uri.filename)
if os.path.isdir(loc): dirs.append(loc)
else:
loc = os.path.realpath(loc)
if loc not in self.__library:
self.__library.add_filename(loc)
elif player.can_play_uri(uri):
if uri not in self.__library:
self.__library.add([RemoteFile(uri)])
else:
error = True
break
ctx.finish(not error, False, etime)
if error:
ErrorMessage(
self, _("Unable to add songs"),
_("<b>%s</b> uses an unsupported protocol.") % uri).run()
else:
if dirs:
copool.add(
self.__library.scan, dirs, self.__status.bar.progress,
cofuncid="library", funcid="library")
def __songlist_drag_data_recv(self, view, *args):
if callable(self.browser.reordered): self.browser.reordered(view)
self.songlist.set_sort_by(None, refresh=False)
def __save_browser(self, *args):
print_d("Saving active browser state")
try: self.browser.save()
except NotImplementedError: pass
def destroy(self, *args):
self.__save_browser()
super(QuodLibetWindow, self).destroy()
def __show_or(self, widget, prop):
ssv = self.song_scroller.get_property('visible')
qxv = self.qexpander.get_property('visible')
self.songpane.set_property('visible', ssv or qxv)
if not ssv:
self.qexpander.set_expanded(True)
self.__expand_or(widget, prop)
def __expand_or(self, widget, prop):
if self.qexpander.get_property('expanded'):
self.songpane.set_property("position", self.__handle_position)
def __moved_pane_handle(self, widget, prop):
if self.qexpander.get_property('expanded'):
self.__handle_position = self.songpane.get_property("position")
def __qex_size_allocate(self, event, param=None):
if not self.qexpander.get_property('expanded'):
p_max = self.songpane.get_property("max-position")
p_cur = self.songpane.get_property("position")
if p_max != p_cur:
self.songpane.set_property("position", p_max)
def __create_menu(self, player, library):
ag = gtk.ActionGroup('QuodLibetWindowActions')
actions = [
('Music', None, _("_Music")),
('SwitchAudioOutputs', gtk.STOCK_FIND, _('_Audio Outputs'), ""),
('BrowseLibrary', gtk.STOCK_FIND, _('_Browse Library'), ""),
("Preferences", gtk.STOCK_PREFERENCES, None, None, None,
self.__preferences),
("Quit", gtk.STOCK_QUIT, None, None, None, self.destroy),
('Filters', None, _("_Filters")),
("PlayedRecently", gtk.STOCK_FIND, _("Recently _Played"),
"", None, self.__filter_menu_actions),
("AddedRecently", gtk.STOCK_FIND, _("Recently _Added"),
"", None, self.__filter_menu_actions),
("TopRated", gtk.STOCK_FIND, _("_Top 40"),
"", None, self.__filter_menu_actions),
("Control", None, _("_Control")),
("EditTags", gtk.STOCK_PROPERTIES, _("Edit _Tags"), "", None,
self.__current_song_prop),
("Information", gtk.STOCK_INFO, None, None, None,
self.__current_song_info),
("Jump", gtk.STOCK_JUMP_TO, _("_Jump to Playing Song"),
"<control>J", None, self.__jump_to_current),
("View", None, _("_View")),
("Help", None, _("_Help")),
("OutputLog", gtk.STOCK_EDIT, _("_Output Log"),
None, None, lambda *args: LoggingWindow(self)),
]
if const.DEBUG:
from quodlibet.debug import cause_error, enc
actions.append(("DebugReload", gtk.STOCK_DIALOG_WARNING,
_("_Edit and Continue"), None, None,
lambda *args: enc.reload()))
actions.append(("DebugCauseError", gtk.STOCK_DIALOG_ERROR,
_("_Cause an Error"), None, None, cause_error))
actions.append(("Previous", gtk.STOCK_MEDIA_PREVIOUS, None,
"<control>comma", None, self.__previous_song))
actions.append(("PlayPause", gtk.STOCK_MEDIA_PLAY, None,
"<control>space", None, self.__play_pause))
actions.append(("Next", gtk.STOCK_MEDIA_NEXT, None,
"<control>period", None, self.__next_song))
ag.add_actions(actions)
act = gtk.Action("About", None, None, gtk.STOCK_ABOUT)
act.connect_object('activate', self.__show_about, player)
ag.add_action_with_accel(act, None)
act = gtk.Action("OnlineHelp", _("Online Help"), None, gtk.STOCK_HELP)
act.connect_object('activate', util.website, const.ONLINE_HELP)
ag.add_action_with_accel(act, "F1")
act = gtk.Action("SearchHelp", _("Search Help"), None, "")
act.connect_object('activate', util.website, const.SEARCH_HELP)
ag.add_action_with_accel(act, None)
act = gtk.Action(
"RefreshLibrary", _("Re_fresh Library"), None, gtk.STOCK_REFRESH)
act.connect('activate', self.__rebuild, False)
ag.add_action_with_accel(act, None)
act = gtk.Action(
"ConnectDisconnect", _("_Connect/Disconnect"), None, gtk.STOCK_REFRESH)
act.connect('activate', self.__toggle_connected, True)
ag.add_action_with_accel(act, None)
for tag_, lab in [
("genre", _("Filter on _Genre")),
("artist", _("Filter on _Artist")),
("album", _("Filter on Al_bum"))]:
act = gtk.Action(
"Filter%s" % util.capitalize(tag_), lab, None, gtk.STOCK_INDEX)
act.connect_object('activate', self.__filter_on, tag_, None, player)
ag.add_action_with_accel(act, None)
for (tag_, accel, label) in [
("genre", "G", _("Random _Genre")),
("artist", "T", _("Random _Artist")),
("album", "M", _("Random Al_bum"))]:
act = gtk.Action("Random%s" % util.capitalize(tag_), label,
None, gtk.STOCK_DIALOG_QUESTION)
act.connect('activate', self.__random, tag_)
ag.add_action_with_accel(act, "<control>" + accel)
ag.add_toggle_actions([
("SongList", None, _("Song _List"), None, None,
self.showhide_playlist,
config.getboolean("memory", "songlist"))])
ag.add_toggle_actions([
("Queue", None, _("_Queue"), None, None,
self.showhide_playqueue,
config.getboolean("memory", "queue"))])
view_actions = []
for i, Kind in enumerate(browsers.browsers):
action = "View" + Kind.__name__
label = Kind.accelerated_name
view_actions.append((action, None, label, None, None, i))
current = browsers.index(config.get("memory", "browser"))
ag.add_radio_actions(
view_actions, current, self.select_browser,
(library, player))
for Kind in browsers.browsers:
if not Kind.in_menu: continue
action = "Browser" + Kind.__name__
label = Kind.accelerated_name
act = gtk.Action(action, label, None, None)
act.connect_object('activate', LibraryBrowser, Kind, library)
ag.add_action_with_accel(act, None)
debug_menu = ""
if const.DEBUG:
debug_menu = ("<separator/>"
"<menuitem action='OutputLog'/>"
"<menuitem action='DebugReload'/>"
"<menuitem action='DebugCauseError'/>")
self.ui = gtk.UIManager()
self.ui.insert_action_group(ag, -1)
menustr = const.MENU % {"browsers": browsers.BrowseLibrary(),
"views": browsers.ViewBrowser(),
"mpd_audio_outputs": self._mpd.browse_audio_outputs(),
"debug": debug_menu}
self.ui.add_ui_from_string(menustr)
# Cute. So. UIManager lets you attach tooltips, but when they're
# for menu items, they just get ignored. So here I get to actually
# attach them.
self.ui.get_widget("/Menu/Music/RefreshLibrary").set_tooltip_text(
_("Check for changes in your library"))
self.ui.get_widget("/Menu/Filters/TopRated").set_tooltip_text(
_("The 40 songs you've played most (more than 40 may "
"be chosen if there are ties)"))
def __show_about(self, player):
about = AboutQuodLibet(self, player)
about.run()
about.destroy()
def __browser_configure(self, paned, event, browser):
if paned.get_property('position-set'):
key = "%s_pos" % browser.__class__.__name__
config.set("browsers", key, str(paned.get_relative()))
def select_browser(self, activator, current, library, player, restore=False):
if isinstance(current, gtk.RadioAction):
current = current.get_current_value()
Browser = browsers.get(current)
config.set("memory", "browser", Browser.__name__)
if self.browser:
container = self.browser.__container
self.browser.unpack(container, self.songpane)
if self.browser.accelerators:
self.remove_accel_group(self.browser.accelerators)
container.destroy()
self.browser.destroy()
self.browser = Browser(library, True)
self.browser.connect('songs-selected', self.__browser_cb)
self.browser.connect('activated', self.__browser_activate)
if restore:
self.browser.restore()
self.browser.activate()
self.browser.finalize(restore)
if self.browser.reordered:
self.songlist.enable_drop()
elif self.browser.dropped:
self.songlist.enable_drop(False)
else: self.songlist.disable_drop()
if self.browser.accelerators:
self.add_accel_group(self.browser.accelerators)
container = self.browser.__container = self.browser.pack(self.songpane)
# Look for a paned if the container is none
sub = container
if not isinstance(container, RPaned):
for child in container.get_children():
if isinstance(child, RPaned):
sub = child
# Save position if container is a RPaned
if isinstance(sub, RPaned):
try:
key = "%s_pos" % self.browser.__class__.__name__
val = config.getfloat("browsers", key)
# Use a minimum restore size
val = max(val, 0.1)
except: val = 0.4
sub.connect(
'notify::position', self.__browser_configure, self.browser)
def set_size(paned, alloc, pos):
paned.set_relative(pos)
paned.disconnect(paned._size_sig)
# The signal disconnects itself! I hate GTK sizing.
del(paned._size_sig)
sig = sub.connect('size-allocate', set_size, val)
sub._size_sig = sig
player.replaygain_profiles[1] = self.browser.replaygain_profiles
player.volume = player.volume
self.__browserbox.add(container)
container.show()
self.__hide_menus()
self.__hide_headers()
self.__refresh_size()
def __update_paused(self, player, paused):
menu = self.ui.get_widget("/Menu/Control/PlayPause")
if paused: key = gtk.STOCK_MEDIA_PLAY
else: key = gtk.STOCK_MEDIA_PAUSE
text = gtk.stock_lookup(key)[1]
menu.get_image().set_from_stock(key, gtk.ICON_SIZE_MENU)
menu.set_label(text)
menu.set_use_underline(True)
def __check_remove_song(self, player, song):
if song is None: return
if not self.browser.dynamic(song):
iter = self.songlist.model.find(song)
if iter:
self.songlist.remove_iters([iter])
self.__set_time()
def __song_ended(self, player, song, stopped):
self.__check_remove_song(player, song)
def __song_changed(self, player, songs):
self.__update_title(player)
for song in songs:
self.__check_remove_song(player, song)
def __update_title(self, player):
song = player.info
title = "QuodMPD"
if song:
title = song.comma("~title~version~~people") + " - " + title
self.set_title(title)
def __song_started(self, player, song):
self.__update_title(player)
for wid in ["Jump", "Next", "EditTags", "Information"]:
self.ui.get_widget('/Menu/Control/'+wid).set_sensitive(bool(song))
for wid in ["FilterAlbum", "FilterArtist", "FilterGenre"]:
self.ui.get_widget('/Menu/Filters/'+wid).set_sensitive(bool(song))
if song:
for h in ['genre', 'artist', 'album']:
self.ui.get_widget(
"/Menu/Filters/Filter%s" % h.capitalize()).set_sensitive(
h in song)
# don't jump on stream changes (player.info != player.song)
if song and player.song is song and not self.songlist._activated and \
config.getboolean("settings", "jump"):
self.__jump_to_current(False)
def __refresh_size(self):
ssv = self.song_scroller.get_property('visible')
qex = self.qexpander.get_property('visible')
brv = self.browser.expand
if (not brv and not (ssv or qex)):
width, height = self.get_size()
height = self.size_request()[1]
self.resize(width, height)
self.set_geometry_hints(None, max_height=height, max_width=32000)
else:
self.set_geometry_hints(None, max_height=-1, max_width=-1)
def showhide_playlist(self, toggle):
self.song_scroller.set_property('visible', toggle.get_active())
self.__refresh_size()
def showhide_playqueue(self, toggle):
self.qexpander.set_property('visible', toggle.get_active())
self.__refresh_size()
def __play_pause(self, *args):
if player.playlist.song is None:
player.playlist.reset()
else: player.playlist.paused ^= True
def __jump_to_current(self, explicit):
"""Select/scroll to the current playing song in the playlist.
If it can't be found tell the browser to properly fill the playlist
with an appropriate selection containing the song.
explicit means that the jump request comes from the user and not
from an event like song-started.
"""
def jump_to(song, select=True):
model = self.songlist.model
if song == model.current:
path = model.current_path
else:
iter = model.find(song)
if iter is None: return
path = model[iter].path
self.songlist.scroll_to_cell(path, use_align=True, row_align=0.5)
if select:
self.songlist.set_cursor(path)
song = player.playlist.song
model = self.songlist.model
# We are not playing a song
if song is None: return
# model.find because the source could be the queue
if song == model.current or (model.find(song) and explicit):
jump_to(song, select=explicit)
elif explicit:
self.browser.scroll(player.playlist.song)
# We need to wait until the browser has finished
# scrolling/filling and the songlist is ready.
# Not perfect, but works for now.
gobject.idle_add(jump_to, song, priority=gobject.PRIORITY_LOW)
def __next_song(self, *args): player.playlist.next()
def __previous_song(self, *args): player.playlist.previous()
def __random(self, item, key):
self.browser.filter_random(key)
def __filter_menu_actions(self, menuitem):
name = menuitem.get_name()
if name == "PlayedRecently":
self.__make_query("#(lastplayed < 7 days ago)")
elif name == "AddedRecently":
self.__make_query("#(added < 7 days ago)")
elif name == "TopRated":
bg = background_filter()
songs = (bg and filter(bg, self.__library)) or self.__library
songs = [song.get("~#playcount", 0) for song in songs]
if len(songs) == 0:
return
songs.sort()
if len(songs) < 40:
self.__make_query("#(playcount > %d)" % (songs[0] - 1))
else:
self.__make_query("#(playcount > %d)" % (songs[-40] - 1))
def __rebuild(self, activator, force):
paths = util.split_scan_dirs(config.get("settings", "scan"))
exclude = config.get("library", "exclude").split(":")
copool.add(self.__library.rebuild,
paths, force, exclude, cofuncid="library", funcid="library")
def __toggle_connected(self, activator, force):
'''Try and connect/disconnect to/from MPD instance'''
if self._mpd.is_connected():
self._mpd.disconnect()
else:
self._mpd.connect()
self._mpd.print_current_song()
# Set up the preferences window.
def __preferences(self, activator):
PreferencesWindow(self)
def __plugins(self, activator):
PluginWindow(self)
def open_location(self, action):
name = GetStringDialog(self, _("Add a Location"),
_("Enter the location of an audio file:"),
okbutton=gtk.STOCK_ADD).run()
if name:
if not util.uri_is_valid(name):
ErrorMessage(
self, _("Unable to add location"),
_("<b>%s</b> is not a valid location.") %(
util.escape(name))).run()
elif not player.can_play_uri(name):
ErrorMessage(
self, _("Unable to add location"),
_("<b>%s</b> uses an unsupported protocol.") %(
util.escape(name))).run()
else:
if name not in self.__library:
self.__library.add([RemoteFile(name)])
def open_chooser(self, action):
if not os.path.exists(self.last_dir):
self.last_dir = const.HOME
if action.get_name() == "AddFolders":
chooser = FolderChooser(self, _("Add Music"), self.last_dir)
cb = gtk.CheckButton(_("Watch this folder for new songs"))
cb.set_active(not config.get("settings", "scan"))
cb.show()
chooser.set_extra_widget(cb)
else:
chooser = FileChooser(
self, _("Add Music"), formats.filter, self.last_dir)
cb = None
fns = chooser.run()
chooser.destroy()
if fns:
if action.get_name() == "AddFolders":
self.last_dir = fns[0]
copool.add(self.__library.scan, fns, funcid="library")
else:
self.last_dir = os.path.basename(fns[0])
for filename in map(os.path.realpath, map(util.fsnative, fns)):
if filename in self.__library: continue
song = self.__library.add_filename(filename)
if not song:
from traceback import format_exception_only as feo
tb = feo(sys.last_type, sys.last_value)
msg = _("%s could not be added to your library.\n\n")
msg %= util.escape(util.fsdecode(
os.path.basename(filename)))
msg += util.escape("".join(tb).decode(
const.ENCODING, "replace"))
d = ErrorMessage(self, _("Unable to add song"), msg)
d.label.set_selectable(True)
d.run()
continue
if cb and cb.get_active():
dirs = util.split_scan_dirs(config.get("settings", "scan"))
for fn in fns:
if fn not in dirs: dirs.append(fn)
dirs = ":".join(dirs)
config.set("settings", "scan", dirs)
def __songs_popup_menu(self, songlist):
path, col = songlist.get_cursor()
header = col.header_name
menu = self.songlist.Menu(header, self.browser, self.__library)
if menu is not None:
return self.songlist.popup_menu(menu, 0,
gtk.get_current_event_time())
def __current_song_prop(self, *args):
song = player.playlist.song
if song: SongProperties(self.__library.librarian, [song], parent=self)
def __current_song_info(self, *args):
song = player.playlist.song
if song: Information(self.__library.librarian, [song], self)
def __hide_menus(self):
menus = {'genre': ["/Menu/Filters/FilterGenre",
"/Menu/Filters/RandomGenre"],
'artist': ["/Menu/Filters/FilterArtist",
"/Menu/Filters/RandomArtist"],
'album': ["/Menu/Filters/FilterAlbum",
"/Menu/Filters/RandomAlbum"],
None: ["/Menu/Filters/PlayedRecently",
"/Menu/Filters/AddedRecently",
"/Menu/Filters/TopRated",
"/Menu/Filters/TopRated"]}
for key, widgets in menus.items():
c = self.browser.can_filter(key)
for widget in widgets:
self.ui.get_widget(widget).set_property('visible', c)
def __browser_activate(self, browser):
model = self.songlist.get_model()
model.reset()
if player.playlist.go_to(model.get_iter_first(), True):
player.playlist.paused = False
def __browser_cb(self, browser, songs, sorted):
if browser.background:
bg = background_filter()
if bg: songs = filter(bg, songs)
self.__set_time(songs=songs)
self.songlist.set_songs(songs, sorted)
def __filter_on(self, header, songs, player):
browser = self.browser
if not browser:
return
# Fall back to the playing song
if songs is None:
if player.song:
songs = [player.song]
else:
return
browser.filter_on(songs, header)
def __hide_headers(self, activator=None):
for column in self.songlist.get_columns():
if self.browser.headers is None:
column.set_visible(True)
else:
for tag in util.tagsplit(column.header_name):
if tag in self.browser.headers:
column.set_visible(True)
break
else: column.set_visible(False)
def __cols_changed(self, songlist):
headers = [col.header_name for col in songlist.get_columns()]
try: headers.remove('~current')
except ValueError: pass
if len(headers) == len(config.get("settings", "headers").split()):
# Not an addition or removal (handled separately)
config.set("settings", "headers", " ".join(headers))
SongList.headers = headers
def __make_query(self, query):
if self.browser.can_filter_text():
self.browser.filter_text(query.encode('utf-8'))
self.browser.activate()
def __set_time(self, *args, **kwargs):
songs = kwargs.get("songs") or self.songlist.get_selected_songs()
if "songs" not in kwargs and len(songs) <= 1:
songs = self.songlist.get_songs()
i = len(songs)
length = sum([song("~#length", 0) for song in songs])
t = self.browser.statusbar(i) % {
'count': i, 'time': util.format_time_long(length)}
self.statusbar.set_default_text(t)
def __init__(self, library, player, headless=False):
super(QuodLibetWindow, self).__init__(dialog=False)
self.last_dir = const.HOME
self.__destroyed = False
self.__update_title(player)
self.set_default_size(550, 450)
main_box = Gtk.VBox()
self.add(main_box)
# create main menubar, load/restore accelerator groups
self.__library = library
ui = self.__create_menu(player, library)
accel_group = ui.get_accel_group()
self.add_accel_group(accel_group)
def scroll_and_jump(*args):
self.__jump_to_current(True, True)
keyval, mod = Gtk.accelerator_parse("<control><shift>J")
accel_group.connect(keyval, mod, 0, scroll_and_jump)
# dbus app menu
AppMenu(self, ui.get_action_groups()[0])
# custom accel map
accel_fn = os.path.join(const.USERDIR, "accels")
Gtk.AccelMap.load(accel_fn)
# save right away so we fill the file with example comments of all
# accels
Gtk.AccelMap.save(accel_fn)
menubar = ui.get_widget("/Menu")
# Since https://git.gnome.org/browse/gtk+/commit/?id=b44df22895c79
# toplevel menu items show an empty 16x16 image. While we don't
# need image items there UIManager creates them by default.
# Work around by removing the empty GtkImages
for child in menubar.get_children():
if isinstance(child, Gtk.ImageMenuItem):
child.set_image(None)
main_box.pack_start(menubar, False, True, 0)
# get the playlist up before other stuff
self.songlist = MainSongList(library, player)
self.songlist.show_all()
self.songlist.connect("key-press-event", self.__songlist_key_press)
self.songlist.connect_after(
'drag-data-received', self.__songlist_drag_data_recv)
self.song_scroller = SongListScroller(
ui.get_widget("/Menu/View/SongList"))
self.song_scroller.add(self.songlist)
self.qexpander = QueueExpander(
ui.get_widget("/Menu/View/Queue"), library, player)
self.playlist = PlaylistMux(
player, self.qexpander.model, self.songlist.model)
top_bar = TopBar(self, player, library)
main_box.pack_start(top_bar, False, True, 0)
self.top_bar = top_bar
self.__browserbox = Alignment(bottom=3)
main_box.pack_start(self.__browserbox, True, True, 0)
statusbox = StatusBarBox(self.songlist.model, player)
self.order = statusbox.order
self.repeat = statusbox.repeat
self.statusbar = statusbox.statusbar
main_box.pack_start(
Alignment(statusbox, border=3, top=-3, right=3),
False, True, 0)
self.songpane = ConfigRVPaned("memory", "queue_position", 0.75)
self.songpane.pack1(self.song_scroller, resize=True, shrink=False)
self.songpane.pack2(self.qexpander, resize=True, shrink=False)
self.__handle_position = self.songpane.get_property("position")
def songpane_button_press_cb(pane, event):
"""If we start to drag the pane handle while the
queue expander is unexpanded, expand it and move the handle
to the bottom, so we can 'drag' the queue out
"""
if event.window != pane.get_handle_window():
return False
if not self.qexpander.get_expanded():
self.qexpander.set_expanded(True)
pane.set_relative(1.0)
return False
self.songpane.connect("button-press-event", songpane_button_press_cb)
self.song_scroller.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::expanded', self.__expand_or)
self.qexpander.connect('draw', self.__qex_size_allocate)
self.songpane.connect('notify', self.__moved_pane_handle)
try:
orders = []
for e in config.getstringlist('memory', 'sortby', []):
orders.append((e[1:], int(e[0])))
except ValueError:
pass
else:
self.songlist.set_sort_orders(orders)
self.browser = None
self.ui = ui
main_box.show_all()
# set at least the playlist. the song should be restored
# after the browser emits the song list
player.setup(self.playlist, None, 0)
self.__first_browser_set = True
restore_browser = not headless
try:
self.select_browser(
self, config.get("memory", "browser"), library, player,
restore_browser)
except:
config.set("memory", "browser", browsers.name(0))
config.save(const.CONFIG)
raise
self.showhide_playlist(ui.get_widget("/Menu/View/SongList"))
self.showhide_playqueue(ui.get_widget("/Menu/View/Queue"))
self.songlist.connect('popup-menu', self.__songs_popup_menu)
self.songlist.connect('columns-changed', self.__cols_changed)
self.songlist.connect('columns-changed', self.__hide_headers)
self.songlist.info.connect("changed", self.__set_time)
lib = library.librarian
connect_destroy(lib, 'changed', self.__song_changed, player)
self._playback_error_dialog = None
player_sigs = [
('song-started', self.__song_started),
('paused', self.__update_paused, True),
('unpaused', self.__update_paused, False),
]
for sig in player_sigs:
connect_destroy(player, *sig)
# make sure we redraw all error indicators before opening
# a dialog (blocking the main loop), so connect after default handlers
connect_after_destroy(player, 'error', self.__player_error)
# connect after to let SongTracker update stats
connect_after_destroy(player, "song-ended", self.__song_ended)
targets = [("text/uri-list", Gtk.TargetFlags.OTHER_APP, DND_URI_LIST)]
targets = [Gtk.TargetEntry.new(*t) for t in targets]
self.drag_dest_set(
Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY)
self.connect('drag-data-received', self.__drag_data_received)
if not headless:
GLib.idle_add(self.__configure_scan_dirs, library)
if config.getboolean('library', 'refresh_on_start'):
self.__rebuild(None, False)
self.connect("key-press-event", self.__key_pressed, player)
self.connect("destroy", self.__destroy)
self.enable_window_tracking("quodlibet")
class QuodLibetWindow(Window, PersistentWindowMixin):
SIG_PYOBJECT = (GObject.SignalFlags.RUN_LAST, None, (object,))
__gsignals__ = {
'artwork-changed': SIG_PYOBJECT,
}
def __init__(self, library, player, headless=False):
super(QuodLibetWindow, self).__init__(dialog=False)
self.last_dir = const.HOME
self.__update_title(player)
self.set_default_size(550, 450)
main_box = Gtk.VBox()
self.add(main_box)
# create main menubar, load/restore accelerator groups
self.__library = library
ui = self.__create_menu(player, library)
accel_group = ui.get_accel_group()
self.add_accel_group(accel_group)
# dbus app menu
AppMenu(self, ui.get_action_groups()[0])
accel_fn = os.path.join(const.USERDIR, "accels")
Gtk.AccelMap.load(accel_fn)
def accel_save_cb(*args):
Gtk.AccelMap.save(accel_fn)
accel_group.connect_object('accel-changed', accel_save_cb, None)
main_box.pack_start(ui.get_widget("/Menu"), False, True, 0)
# get the playlist up before other stuff
self.songlist = MainSongList(library, player)
self.songlist.show_all()
self.songlist.connect_after(
'drag-data-received', self.__songlist_drag_data_recv)
self.song_scroller = SongListScroller(
ui.get_widget("/Menu/View/SongList"))
self.song_scroller.add(self.songlist)
self.qexpander = QueueExpander(
ui.get_widget("/Menu/View/Queue"), library, player)
self.playlist = PlaylistMux(
player, self.qexpander.model, self.songlist.model)
top_bar = TopBar(self, player, library)
main_box.pack_start(top_bar, False, True, 0)
self.top_bar = top_bar
self.__browserbox = Alignment(bottom=3)
main_box.pack_start(self.__browserbox, True, True, 0)
statusbox = StatusBarBox(self.songlist.model, player)
self.order = statusbox.order
self.repeat = statusbox.repeat
self.statusbar = statusbox.statusbar
main_box.pack_start(
Alignment(statusbox, border=3, top=-3, right=3),
False, True, 0)
self.songpane = ConfigRVPaned("memory", "queue_position", 0.75)
self.songpane.pack1(self.song_scroller, resize=True, shrink=False)
self.songpane.pack2(self.qexpander, resize=True, shrink=False)
self.__handle_position = self.songpane.get_property("position")
def songpane_button_press_cb(pane, event):
"""If we start to drag the pane handle while the
queue expander is unexpanded, expand it and move the handle
to the bottom, so we can 'drag' the queue out
"""
if event.window != pane.get_handle_window():
return False
if not self.qexpander.get_expanded():
self.qexpander.set_expanded(True)
pane.set_relative(1.0)
return False
self.songpane.connect("button-press-event", songpane_button_press_cb)
self.song_scroller.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::expanded', self.__expand_or)
self.qexpander.connect('draw', self.__qex_size_allocate)
self.songpane.connect('notify', self.__moved_pane_handle)
try:
orders = []
for e in config.getstringlist('memory', 'sortby', []):
orders.append((e[1:], int(e[0])))
except ValueError:
pass
else:
self.songlist.set_sort_orders(orders)
self.browser = None
self.ui = ui
main_box.show_all()
try:
self.select_browser(
self, config.get("memory", "browser"), library, player, True)
except:
config.set("memory", "browser", browsers.name(0))
config.save(const.CONFIG)
raise
# set at least the playlist before the mainloop starts..
player.setup(self.playlist, None, 0)
def delayed_song_set():
self.__delayed_setup = None
song = library.get(config.get("memory", "song"))
seek_pos = config.getint("memory", "seek", 0)
config.set("memory", "seek", 0)
player.setup(self.playlist, song, seek_pos)
self.__delayed_setup = GLib.idle_add(delayed_song_set)
self.showhide_playlist(ui.get_widget("/Menu/View/SongList"))
self.showhide_playqueue(ui.get_widget("/Menu/View/Queue"))
self.songlist.connect('popup-menu', self.__songs_popup_menu)
self.songlist.connect('columns-changed', self.__cols_changed)
self.songlist.connect('columns-changed', self.__hide_headers)
self.songlist.info.connect("changed", self.__set_time)
lib = library.librarian
gobject_weak(lib.connect_object, 'changed', self.__song_changed,
player, parent=self)
self._playback_error_dialog = None
player_sigs = [
('song-started', self.__song_started),
('paused', self.__update_paused, True),
('unpaused', self.__update_paused, False),
]
for sig in player_sigs:
gobject_weak(player.connect, *sig, **{"parent": self})
# make sure we redraw all error indicators before opening
# a dialog (blocking the main loop), so connect after default handlers
gobject_weak(player.connect_after, 'error',
self.__player_error, **{"parent": self})
# connect after to let SongTracker update stats
player_sigs.append(
gobject_weak(player.connect_after, "song-ended",
self.__song_ended, parent=self))
targets = [("text/uri-list", Gtk.TargetFlags.OTHER_APP, DND_URI_LIST)]
targets = [Gtk.TargetEntry.new(*t) for t in targets]
self.drag_dest_set(
Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY)
self.connect('drag-data-received', self.__drag_data_received)
if not headless:
GLib.idle_add(self.__configure_scan_dirs, library)
if config.getboolean('library', 'refresh_on_start'):
self.__rebuild(None, False)
self.connect_object("key-press-event", self.__key_pressed, player)
self.connect("delete-event", self.__save_browser)
self.connect("destroy", self.__destroy)
self.enable_window_tracking("quodlibet")
def __player_error(self, player, song, player_error):
# it's modal, but mmkeys etc. can still trigger new ones
if self._playback_error_dialog:
self._playback_error_dialog.destroy()
dialog = PlaybackErrorDialog(self, player_error)
self._playback_error_dialog = dialog
dialog.run()
self._playback_error_dialog = None
def __configure_scan_dirs(self, library):
"""Get user to configure scan dirs, if none is set up"""
if not get_scan_dirs() and not len(library) and \
quodlibet.is_first_session("quodlibet"):
print_d("Couldn't find any scan dirs")
if qltk.ConfirmAction(self, _("Set up library directories?"),
_("You don't have any music library set up. "
"Would you like to do that now?")).run():
prefs = PreferencesWindow(self)
prefs.set_page("library")
prefs.show()
def __add_bookmark(self, librarian, player):
if player.song:
position = player.get_position() // 1000
bookmarks = player.song.bookmarks
new_mark = (position, _("Bookmark Name"))
if new_mark not in bookmarks:
bookmarks.append(new_mark)
player.song.bookmarks = bookmarks
def __edit_bookmarks(self, librarian, player):
if player.song:
window = EditBookmarks(self, librarian, player)
window.show()
def __key_pressed(self, player, event):
if not player.song:
return
def seek_relative(seconds):
current = player.get_position()
current += seconds * 1000
current = min(player.song("~#length") * 1000 - 1, current)
current = max(0, current)
player.seek(current)
if qltk.is_accel(event, "<alt>Right"):
seek_relative(10)
return True
elif qltk.is_accel(event, "<alt>Left"):
seek_relative(-10)
return True
def __destroy(self, *args):
if self.__delayed_setup:
GLib.source_remove(self.__delayed_setup)
# The tray icon plugin tries to unhide QL because it gets disabled
# on Ql exit. The window should stay hidden after destroy.
self.show = lambda: None
self.present = self.show
def __drag_data_received(self, widget, ctx, x, y, sel, tid, etime):
assert tid == DND_URI_LIST
uris = sel.get_uris()
dirs = []
error = False
for uri in uris:
try:
uri = URI(uri)
except ValueError:
continue
if uri.is_filename:
loc = os.path.normpath(uri.filename)
if os.path.isdir(loc):
dirs.append(loc)
else:
loc = os.path.realpath(loc)
if loc not in self.__library:
self.__library.add_filename(loc)
elif app.player.can_play_uri(uri):
if uri not in self.__library:
self.__library.add([RemoteFile(uri)])
else:
error = True
break
Gtk.drag_finish(ctx, not error, False, etime)
if error:
ErrorMessage(
self, _("Unable to add songs"),
_("<b>%s</b> uses an unsupported protocol.") % uri).run()
else:
if dirs:
copool.add(
self.__library.scan, dirs,
cofuncid="library", funcid="library")
def __songlist_drag_data_recv(self, view, *args):
if callable(self.browser.reordered):
self.browser.reordered(view)
self.songlist.clear_sort()
def __save_browser(self, *args):
print_d("Saving active browser state")
try:
self.browser.save()
except NotImplementedError:
pass
def destroy(self, *args):
self.__save_browser()
super(QuodLibetWindow, self).destroy()
def __show_or(self, widget, prop):
ssv = self.song_scroller.get_property('visible')
qxv = self.qexpander.get_property('visible')
self.songpane.set_property('visible', ssv or qxv)
if not ssv:
self.qexpander.set_expanded(True)
self.__expand_or(widget, prop)
def __expand_or(self, widget, prop):
if self.qexpander.get_property('expanded'):
self.songpane.set_property("position", self.__handle_position)
def __moved_pane_handle(self, widget, prop):
if self.qexpander.get_property('expanded'):
self.__handle_position = self.songpane.get_property("position")
def __qex_size_allocate(self, event, param=None):
if not self.qexpander.get_property('expanded'):
p_max = self.songpane.get_property("max-position")
p_cur = self.songpane.get_property("position")
if p_max != p_cur:
self.songpane.set_property("position", p_max)
def __create_menu(self, player, library):
ag = Gtk.ActionGroup.new('QuodLibetWindowActions')
def logging_cb(*args):
window = LoggingWindow(self)
window.show()
actions = [
('Music', None, _("_Music")),
('AddFolders', Gtk.STOCK_ADD, _('_Add a Folder...'),
"<control>O", None, self.open_chooser),
('AddFiles', Gtk.STOCK_ADD, _('_Add a File...'),
None, None, self.open_chooser),
('AddLocation', Gtk.STOCK_ADD, _('_Add a Location...'),
None, None, self.open_location),
('BrowseLibrary', Gtk.STOCK_FIND, _('Open _Browser'), ""),
("Preferences", Gtk.STOCK_PREFERENCES, None, None, None,
self.__preferences),
("Plugins", Gtk.STOCK_EXECUTE, _("_Plugins"), None, None,
self.__plugins),
("Quit", Gtk.STOCK_QUIT, None, None, None, self.destroy),
('Filters', None, _("_Filters")),
("PlayedRecently", Gtk.STOCK_FIND, _("Recently _Played"),
"", None, self.__filter_menu_actions),
("AddedRecently", Gtk.STOCK_FIND, _("Recently _Added"),
"", None, self.__filter_menu_actions),
("TopRated", Gtk.STOCK_FIND, _("_Top 40"),
"", None, self.__filter_menu_actions),
("All", Gtk.STOCK_FIND, _("All _Songs"),
"", None, self.__filter_menu_actions),
("Control", None, _("_Control")),
("EditTags", Gtk.STOCK_PROPERTIES, _("Edit _Tags"), "", None,
self.__current_song_prop),
("Information", Gtk.STOCK_INFO, None, None, None,
self.__current_song_info),
("Jump", Gtk.STOCK_JUMP_TO, _("_Jump to Playing Song"),
"<control>J", None, self.__jump_to_current),
("View", None, _("_View")),
("Help", None, _("_Help")),
("OutputLog", Gtk.STOCK_EDIT, _("_Output Log"),
None, None, logging_cb),
]
actions.append(("Previous", Gtk.STOCK_MEDIA_PREVIOUS, None,
"<control>comma", None, self.__previous_song))
actions.append(("PlayPause", Gtk.STOCK_MEDIA_PLAY, None,
"<control>space", None, self.__play_pause))
actions.append(("Next", Gtk.STOCK_MEDIA_NEXT, None,
"<control>period", None, self.__next_song))
ag.add_actions(actions)
act = Gtk.ToggleAction.new("StopAfter",
_("Stop After This Song"), None, "")
ag.add_action_with_accel(act, "<shift>space")
# access point for the tray icon
self.stop_after = act
act = Gtk.Action.new(
"AddBookmark", _("Add Bookmark"), None, Gtk.STOCK_ADD)
act.connect_object('activate', self.__add_bookmark,
library.librarian, player)
ag.add_action_with_accel(act, "<ctrl>D")
act = Gtk.Action.new("EditBookmarks", _(u"Edit Bookmarks…"), None, "")
act.connect_object('activate', self.__edit_bookmarks,
library.librarian, player)
ag.add_action_with_accel(act, "<ctrl>B")
act = Gtk.Action.new("About", None, None, Gtk.STOCK_ABOUT)
act.connect_object('activate', self.__show_about, player)
ag.add_action_with_accel(act, None)
act = Gtk.Action.new(
"OnlineHelp", _("Online Help"), None, Gtk.STOCK_HELP)
act.connect_object('activate', util.website, const.ONLINE_HELP)
ag.add_action_with_accel(act, "F1")
act = Gtk.Action.new("SearchHelp", _("Search Help"), None, "")
act.connect_object('activate', util.website, const.SEARCH_HELP)
ag.add_action_with_accel(act, None)
act = Gtk.Action.new(
"RefreshLibrary", _("Re_fresh Library"), None, Gtk.STOCK_REFRESH)
act.connect('activate', self.__rebuild, False)
ag.add_action_with_accel(act, None)
for tag_, lab in [
("genre", _("Filter on _Genre")),
("artist", _("Filter on _Artist")),
("album", _("Filter on Al_bum"))]:
act = Gtk.Action.new(
"Filter%s" % util.capitalize(tag_), lab, None, Gtk.STOCK_INDEX)
act.connect_object('activate',
self.__filter_on, tag_, None, player)
ag.add_action_with_accel(act, None)
for (tag_, accel, label) in [
("genre", "G", _("Random _Genre")),
("artist", "T", _("Random _Artist")),
("album", "M", _("Random Al_bum"))]:
act = Gtk.Action.new("Random%s" % util.capitalize(tag_), label,
None, Gtk.STOCK_DIALOG_QUESTION)
act.connect('activate', self.__random, tag_)
ag.add_action_with_accel(act, "<control>" + accel)
ag.add_toggle_actions([
("SongList", None, _("Song _List"), None, None,
self.showhide_playlist,
config.getboolean("memory", "songlist"))])
ag.add_toggle_actions([
("Queue", None, _("_Queue"), None, None,
self.showhide_playqueue,
config.getboolean("memory", "queue"))])
view_actions = []
for i, Kind in enumerate(browsers.browsers):
action = "View" + Kind.__name__
label = Kind.accelerated_name
view_actions.append((action, None, label, None, None, i))
current = browsers.index(config.get("memory", "browser"))
def action_callback(view_action, current):
self.select_browser(view_action, current, library, player)
ag.add_radio_actions(
view_actions, current, action_callback,
None)
for Kind in browsers.browsers:
if not Kind.in_menu:
continue
action = "Browser" + Kind.__name__
label = Kind.accelerated_name
act = Gtk.Action.new(action, label, None, None)
act.connect_object('activate', LibraryBrowser.open, Kind, library)
ag.add_action_with_accel(act, None)
debug_menu = ""
if const.DEBUG:
debug_menu = (
"<separator/>"
"<menuitem action='OutputLog' always-show-image='true'/>")
ui = Gtk.UIManager()
ui.insert_action_group(ag, -1)
menustr = const.MENU % {"browsers": browsers.BrowseLibrary(),
"views": browsers.ViewBrowser(),
"debug": debug_menu}
ui.add_ui_from_string(menustr)
# Cute. So. UIManager lets you attach tooltips, but when they're
# for menu items, they just get ignored. So here I get to actually
# attach them.
ui.get_widget("/Menu/Music/RefreshLibrary").set_tooltip_text(
_("Check for changes in your library"))
ui.get_widget("/Menu/Filters/TopRated").set_tooltip_text(
_("The 40 songs you've played most (more than 40 may "
"be chosen if there are ties)"))
return ui
def __show_about(self, player):
about = AboutQuodLibet(self, player)
about.run()
about.destroy()
def __browser_configure(self, paned, event, browser):
if paned.get_property('position-set'):
key = "%s_pos" % browser.__class__.__name__
config.set("browsers", key, str(paned.get_relative()))
def select_browser(self, activator, current, library, player,
restore=False):
if isinstance(current, Gtk.RadioAction):
current = current.get_current_value()
Browser = browsers.get(current)
config.set("memory", "browser", Browser.__name__)
if self.browser:
container = self.browser.__container
self.browser.unpack(container, self.songpane)
if self.browser.accelerators:
self.remove_accel_group(self.browser.accelerators)
container.destroy()
self.browser.destroy()
self.browser = Browser(library, True)
self.browser.connect('songs-selected', self.__browser_cb)
self.browser.connect('activated', self.__browser_activate)
if restore:
self.browser.restore()
self.browser.activate()
self.browser.finalize(restore)
if self.browser.reordered:
self.songlist.enable_drop()
elif self.browser.dropped:
self.songlist.enable_drop(False)
else:
self.songlist.disable_drop()
if self.browser.accelerators:
self.add_accel_group(self.browser.accelerators)
container = self.browser.__container = self.browser.pack(self.songpane)
# find a paned and save the position
paned = None
for widget in qltk.find_widgets(container, RPaned):
if widget is not self.songpane:
paned = widget
break
if paned:
try:
key = "%s_pos" % self.browser.__class__.__name__
val = config.getfloat("browsers", key)
# Use a minimum restore size
val = max(val, 0.1)
except:
val = 0.4
paned.connect(
'notify::position', self.__browser_configure, self.browser)
paned.set_relative(val)
player.replaygain_profiles[1] = self.browser.replaygain_profiles
player.volume = player.volume
self.__browserbox.add(container)
container.show()
self.__hide_menus()
self.__hide_headers()
self.__refresh_size()
def __update_paused(self, player, paused):
menu = self.ui.get_widget("/Menu/Control/PlayPause")
if paused:
key = Gtk.STOCK_MEDIA_PLAY
else:
key = Gtk.STOCK_MEDIA_PAUSE
text = Gtk.stock_lookup(key).label
menu.get_image().set_from_stock(key, Gtk.IconSize.MENU)
menu.set_label(text)
menu.set_use_underline(True)
def __song_ended(self, player, song, stopped):
# check if the song should be removed base on the
# active filter of the current browser
active_filter = self.browser.active_filter
if song and active_filter and not active_filter(song):
iter_ = self.songlist.model.find(song)
if iter_:
self.songlist.remove_iters([iter_])
if self.stop_after.get_active():
player.paused = True
self.stop_after.set_active(False)
def __song_changed(self, player, songs):
if player.info in songs:
self.__update_title(player)
def __update_title(self, player):
song = player.info
title = "Quod Libet"
if song:
title = song.comma("~title~version~~people") + " - " + title
self.set_title(title)
def __song_started(self, player, song):
self.__update_title(player)
for wid in ["Jump", "Next", "EditTags", "Information",
"EditBookmarks", "AddBookmark", "StopAfter"]:
self.ui.get_widget(
'/Menu/Control/' + wid).set_sensitive(bool(song))
for wid in ["FilterAlbum", "FilterArtist", "FilterGenre"]:
self.ui.get_widget(
'/Menu/Filters/' + wid).set_sensitive(bool(song))
if song:
for h in ['genre', 'artist', 'album']:
self.ui.get_widget(
"/Menu/Filters/Filter%s" % h.capitalize()).set_sensitive(
h in song)
# don't jump on stream changes (player.info != player.song)
if song and player.song is song and not self.songlist._activated and \
config.getboolean("settings", "jump"):
self.__jump_to_current(False)
def __refresh_size(self):
ssv = self.song_scroller.get_property('visible')
qex = self.qexpander.get_property('visible')
if ssv or qex:
return
# Handle more later if needed..
if not isinstance(self.browser, Gtk.Box):
return
# If a child expands the browser will take the new space
for child in self.browser.get_children():
if self.browser.query_child_packing(child)[0]:
break
else:
# no expanding child, make the window smaller instead
width, height = self.get_size()
height = self.size_request().height
self.resize(width, height)
def showhide_playlist(self, toggle):
self.song_scroller.set_property('visible', toggle.get_active())
self.__refresh_size()
def showhide_playqueue(self, toggle):
self.qexpander.set_property('visible', toggle.get_active())
self.__refresh_size()
def __play_pause(self, *args):
if app.player.song is None:
app.player.reset()
else:
app.player.paused ^= True
def __jump_to_current(self, explicit):
"""Select/scroll to the current playing song in the playlist.
If it can't be found tell the browser to properly fill the playlist
with an appropriate selection containing the song.
explicit means that the jump request comes from the user and not
from an event like song-started.
"""
def idle_jump_to(song, select):
ok = self.songlist.jump_to_song(song, select=select)
if ok:
self.songlist.grab_focus()
return False
song = app.player.song
# We are not playing a song
if song is None:
return
ok = self.songlist.jump_to_song(song, select=explicit)
if ok:
self.songlist.grab_focus()
elif explicit:
# if we can't find it and the user requested it, try harder
self.browser.scroll(song)
# We need to wait until the browser has finished
# scrolling/filling and the songlist is ready.
# Not perfect, but works for now.
GLib.idle_add(
idle_jump_to, song, explicit, priority=GLib.PRIORITY_LOW)
def __next_song(self, *args):
app.player.next()
def __previous_song(self, *args):
app.player.previous()
def __random(self, item, key):
self.browser.filter_random(key)
def __filter_menu_actions(self, menuitem):
name = menuitem.get_name()
if name == "PlayedRecently":
self.__make_query("#(lastplayed < 7 days ago)")
elif name == "AddedRecently":
self.__make_query("#(added < 7 days ago)")
elif name == "TopRated":
bg = background_filter()
songs = (bg and filter(bg, self.__library)) or self.__library
songs = [song.get("~#playcount", 0) for song in songs]
if len(songs) == 0:
return
songs.sort()
if len(songs) < 40:
self.__make_query("#(playcount > %d)" % (songs[0] - 1))
else:
self.__make_query("#(playcount > %d)" % (songs[-40] - 1))
elif name == "All":
self.browser.unfilter()
def __rebuild(self, activator, force):
scan_library(self.__library, force)
# Set up the preferences window.
def __preferences(self, activator):
window = PreferencesWindow(self)
window.show()
def __plugins(self, activator):
window = PluginWindow(self)
window.show()
def open_location(self, action):
name = GetStringDialog(self, _("Add a Location"),
_("Enter the location of an audio file:"),
okbutton=Gtk.STOCK_ADD).run()
if name:
if not util.uri_is_valid(name):
ErrorMessage(
self, _("Unable to add location"),
_("<b>%s</b> is not a valid location.") % (
util.escape(name))).run()
elif not app.player.can_play_uri(name):
ErrorMessage(
self, _("Unable to add location"),
_("<b>%s</b> uses an unsupported protocol.") % (
util.escape(name))).run()
else:
if name not in self.__library:
self.__library.add([RemoteFile(name)])
def open_chooser(self, action):
last_dir = self.last_dir
if not os.path.exists(last_dir):
last_dir = const.HOME
class MusicFolderChooser(FolderChooser):
def __init__(self, parent, init_dir):
super(MusicFolderChooser, self).__init__(
parent, _("Add Music"), init_dir)
cb = Gtk.CheckButton(_("Watch this folder for new songs"))
# enable if no folders are being watched
cb.set_active(not get_scan_dirs())
cb.show()
self.set_extra_widget(cb)
def run(self):
fns = super(MusicFolderChooser, self).run()
cb = self.get_extra_widget()
return fns, cb.get_active()
class MusicFileChooser(FileChooser):
def __init__(self, parent, init_dir):
super(MusicFileChooser, self).__init__(
parent, _("Add Music"), formats.filter, init_dir)
if action.get_name() == "AddFolders":
dialog = MusicFolderChooser(self, last_dir)
fns, do_watch = dialog.run()
dialog.destroy()
if fns:
fns = map(glib2fsnative, fns)
# scan them
self.last_dir = fns[0]
copool.add(self.__library.scan, fns, funcid="library")
# add them as library scan directory
if do_watch:
dirs = get_scan_dirs()
for fn in fns:
if fn not in dirs:
dirs.append(fn)
set_scan_dirs(dirs)
else:
dialog = MusicFileChooser(self, last_dir)
fns = dialog.run()
dialog.destroy()
if fns:
fns = map(glib2fsnative, fns)
self.last_dir = os.path.dirname(fns[0])
for filename in map(os.path.realpath, fns):
self.__library.add_filename(filename)
def __songs_popup_menu(self, songlist):
path, col = songlist.get_cursor()
header = col.header_name
menu = self.songlist.Menu(header, self.browser, self.__library)
if menu is not None:
return self.songlist.popup_menu(menu, 0,
Gtk.get_current_event_time())
def __current_song_prop(self, *args):
song = app.player.song
if song:
librarian = self.__library.librarian
window = SongProperties(librarian, [song], parent=self)
window.show()
def __current_song_info(self, *args):
song = app.player.song
if song:
librarian = self.__library.librarian
window = Information(librarian, [song], self)
window.show()
def __hide_menus(self):
menus = {'genre': ["/Menu/Filters/FilterGenre",
"/Menu/Filters/RandomGenre"],
'artist': ["/Menu/Filters/FilterArtist",
"/Menu/Filters/RandomArtist"],
'album': ["/Menu/Filters/FilterAlbum",
"/Menu/Filters/RandomAlbum"],
None: ["/Menu/Filters/PlayedRecently",
"/Menu/Filters/AddedRecently",
"/Menu/Filters/TopRated",
"/Menu/Filters/All"]}
for key, widgets in menus.items():
c = self.browser.can_filter(key)
for widget in widgets:
self.ui.get_widget(widget).set_property('visible', c)
def __browser_activate(self, browser):
model = self.songlist.get_model()
model.reset()
if app.player.go_to(model.get_iter_first(), True):
app.player.paused = False
def __browser_cb(self, browser, songs, sorted):
if browser.background:
bg = background_filter()
if bg:
songs = filter(bg, songs)
self.songlist.set_songs(songs, sorted)
def __filter_on(self, header, songs, player):
browser = self.browser
if not browser:
return
# Fall back to the playing song
if songs is None:
if player.song:
songs = [player.song]
else:
return
browser.filter_on(songs, header)
def __hide_headers(self, activator=None):
for column in self.songlist.get_columns():
if self.browser.headers is None:
column.set_visible(True)
else:
for tag in util.tagsplit(column.header_name):
if tag in self.browser.headers:
column.set_visible(True)
break
else:
column.set_visible(False)
def __cols_changed(self, songlist):
headers = [col.header_name for col in songlist.get_columns()]
try:
headers.remove('~current')
except ValueError:
pass
if len(headers) == len(get_columns()):
# Not an addition or removal (handled separately)
set_columns(headers)
SongList.headers = headers
def __make_query(self, query):
if self.browser.can_filter_text():
self.browser.filter_text(query.encode('utf-8'))
self.browser.activate()
def __set_time(self, info, songs):
i = len(songs)
length = sum(song.get("~#length", 0) for song in songs)
t = self.browser.statusbar(i) % {
'count': i, 'time': util.format_time_long(length)}
self.statusbar.set_default_text(t)
def __init__(self, library, player, headless=False, restore_cb=None):
super(QuodLibetWindow, self).__init__(dialog=False)
self.__destroyed = False
self.__update_title(player)
self.set_default_size(600, 480)
main_box = Gtk.VBox()
self.add(main_box)
self.side_book = qltk.Notebook()
# get the playlist up before other stuff
self.songlist = MainSongList(library, player)
self.songlist.connect("key-press-event", self.__songlist_key_press)
self.songlist.connect_after(
'drag-data-received', self.__songlist_drag_data_recv)
self.song_scroller = ScrolledWindow()
self.song_scroller.set_policy(
Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
self.song_scroller.set_shadow_type(Gtk.ShadowType.IN)
self.song_scroller.add(self.songlist)
self.qexpander = QueueExpander(library, player)
self.qexpander.set_no_show_all(True)
self.qexpander.set_visible(config.getboolean("memory", "queue"))
def on_queue_visible(qex, param):
config.set("memory", "queue", str(qex.get_visible()))
self.qexpander.connect("notify::visible", on_queue_visible)
self.playlist = PlaylistMux(
player, self.qexpander.model, self.songlist.model)
self.__player = player
# create main menubar, load/restore accelerator groups
self.__library = library
ui = self.__create_menu(player, library)
accel_group = ui.get_accel_group()
self.add_accel_group(accel_group)
def scroll_and_jump(*args):
self.__jump_to_current(True, None, True)
keyval, mod = Gtk.accelerator_parse("<Primary><shift>J")
accel_group.connect(keyval, mod, 0, scroll_and_jump)
# custom accel map
accel_fn = os.path.join(quodlibet.get_user_dir(), "accels")
Gtk.AccelMap.load(accel_fn)
# save right away so we fill the file with example comments of all
# accels
Gtk.AccelMap.save(accel_fn)
menubar = ui.get_widget("/Menu")
# Since https://git.gnome.org/browse/gtk+/commit/?id=b44df22895c79
# toplevel menu items show an empty 16x16 image. While we don't
# need image items there UIManager creates them by default.
# Work around by removing the empty GtkImages
for child in menubar.get_children():
if isinstance(child, Gtk.ImageMenuItem):
child.set_image(None)
main_box.pack_start(menubar, False, True, 0)
top_bar = TopBar(self, player, library)
main_box.pack_start(top_bar, False, True, 0)
self.top_bar = top_bar
self.__browserbox = Align(bottom=3)
self.__paned = paned = ConfigRHPaned("memory", "sidebar_pos", 0.25)
paned.pack1(self.__browserbox, resize=True)
# We'll pack2 when necessary (when the first sidebar plugin is set up)
main_box.pack_start(paned, True, True, 0)
play_order = PlayOrderWidget(self.songlist.model, player)
statusbox = StatusBarBox(play_order, self.qexpander)
self.order = play_order
self.statusbar = statusbox.statusbar
main_box.pack_start(
Align(statusbox, border=3, top=-3),
False, True, 0)
self.songpane = SongListPaned(self.song_scroller, self.qexpander)
self.songpane.show_all()
try:
orders = []
for e in config.getstringlist('memory', 'sortby', []):
orders.append((e[1:], int(e[0])))
except ValueError:
pass
else:
self.songlist.set_sort_orders(orders)
self.browser = None
self.ui = ui
main_box.show_all()
self._playback_error_dialog = None
connect_destroy(player, 'song-started', self.__song_started)
connect_destroy(player, 'paused', self.__update_paused, True)
connect_destroy(player, 'unpaused', self.__update_paused, False)
# make sure we redraw all error indicators before opening
# a dialog (blocking the main loop), so connect after default handlers
connect_after_destroy(player, 'error', self.__player_error)
# connect after to let SongTracker update stats
connect_after_destroy(player, "song-ended", self.__song_ended)
# set at least the playlist. the song should be restored
# after the browser emits the song list
player.setup(self.playlist, None, 0)
self.__restore_cb = restore_cb
self.__first_browser_set = True
restore_browser = not headless
try:
self._select_browser(
self, config.get("memory", "browser"), library, player,
restore_browser)
except:
config.set("memory", "browser", browsers.name(browsers.default))
config.save()
raise
self.songlist.connect('popup-menu', self.__songs_popup_menu)
self.songlist.connect('columns-changed', self.__cols_changed)
self.songlist.connect('columns-changed', self.__hide_headers)
self.songlist.info.connect("changed", self.__set_totals)
lib = library.librarian
connect_destroy(lib, 'changed', self.__song_changed, player)
targets = [("text/uri-list", Gtk.TargetFlags.OTHER_APP, DND_URI_LIST)]
targets = [Gtk.TargetEntry.new(*t) for t in targets]
self.drag_dest_set(
Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY)
self.connect('drag-data-received', self.__drag_data_received)
if not headless:
on_first_map(self, self.__configure_scan_dirs, library)
if config.getboolean('library', 'refresh_on_start'):
self.__rebuild(None, False)
self.connect("key-press-event", self.__key_pressed, player)
self.connect("destroy", self.__destroy)
self.enable_window_tracking("quodlibet")
class QuodLibetWindow(Window, PersistentWindowMixin):
def __init__(self, library, player, headless=False):
super(QuodLibetWindow, self).__init__(dialog=False)
self.last_dir = const.HOME
self.__destroyed = False
self.__update_title(player)
self.set_default_size(550, 450)
main_box = Gtk.VBox()
self.add(main_box)
# create main menubar, load/restore accelerator groups
self.__library = library
ui = self.__create_menu(player, library)
accel_group = ui.get_accel_group()
self.add_accel_group(accel_group)
def scroll_and_jump(*args):
self.__jump_to_current(True, True)
keyval, mod = Gtk.accelerator_parse("<control><shift>J")
accel_group.connect(keyval, mod, 0, scroll_and_jump)
# dbus app menu
AppMenu(self, ui.get_action_groups()[0])
# custom accel map
accel_fn = os.path.join(const.USERDIR, "accels")
Gtk.AccelMap.load(accel_fn)
# save right away so we fill the file with example comments of all
# accels
Gtk.AccelMap.save(accel_fn)
menubar = ui.get_widget("/Menu")
# Since https://git.gnome.org/browse/gtk+/commit/?id=b44df22895c79
# toplevel menu items show an empty 16x16 image. While we don't
# need image items there UIManager creates them by default.
# Work around by removing the empty GtkImages
for child in menubar.get_children():
if isinstance(child, Gtk.ImageMenuItem):
child.set_image(None)
main_box.pack_start(menubar, False, True, 0)
# get the playlist up before other stuff
self.songlist = MainSongList(library, player)
self.songlist.show_all()
self.songlist.connect("key-press-event", self.__songlist_key_press)
self.songlist.connect_after(
'drag-data-received', self.__songlist_drag_data_recv)
self.song_scroller = SongListScroller(
ui.get_widget("/Menu/View/SongList"))
self.song_scroller.add(self.songlist)
self.qexpander = QueueExpander(
ui.get_widget("/Menu/View/Queue"), library, player)
self.playlist = PlaylistMux(
player, self.qexpander.model, self.songlist.model)
top_bar = TopBar(self, player, library)
main_box.pack_start(top_bar, False, True, 0)
self.top_bar = top_bar
self.__browserbox = Alignment(bottom=3)
main_box.pack_start(self.__browserbox, True, True, 0)
statusbox = StatusBarBox(self.songlist.model, player)
self.order = statusbox.order
self.repeat = statusbox.repeat
self.statusbar = statusbox.statusbar
main_box.pack_start(
Alignment(statusbox, border=3, top=-3, right=3),
False, True, 0)
self.songpane = ConfigRVPaned("memory", "queue_position", 0.75)
self.songpane.pack1(self.song_scroller, resize=True, shrink=False)
self.songpane.pack2(self.qexpander, resize=True, shrink=False)
self.__handle_position = self.songpane.get_property("position")
def songpane_button_press_cb(pane, event):
"""If we start to drag the pane handle while the
queue expander is unexpanded, expand it and move the handle
to the bottom, so we can 'drag' the queue out
"""
if event.window != pane.get_handle_window():
return False
if not self.qexpander.get_expanded():
self.qexpander.set_expanded(True)
pane.set_relative(1.0)
return False
self.songpane.connect("button-press-event", songpane_button_press_cb)
self.song_scroller.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::expanded', self.__expand_or)
self.qexpander.connect('draw', self.__qex_size_allocate)
self.songpane.connect('notify', self.__moved_pane_handle)
try:
orders = []
for e in config.getstringlist('memory', 'sortby', []):
orders.append((e[1:], int(e[0])))
except ValueError:
pass
else:
self.songlist.set_sort_orders(orders)
self.browser = None
self.ui = ui
main_box.show_all()
# set at least the playlist. the song should be restored
# after the browser emits the song list
player.setup(self.playlist, None, 0)
self.__first_browser_set = True
restore_browser = not headless
try:
self.select_browser(
self, config.get("memory", "browser"), library, player,
restore_browser)
except:
config.set("memory", "browser", browsers.name(0))
config.save(const.CONFIG)
raise
self.showhide_playlist(ui.get_widget("/Menu/View/SongList"))
self.showhide_playqueue(ui.get_widget("/Menu/View/Queue"))
self.songlist.connect('popup-menu', self.__songs_popup_menu)
self.songlist.connect('columns-changed', self.__cols_changed)
self.songlist.connect('columns-changed', self.__hide_headers)
self.songlist.info.connect("changed", self.__set_time)
lib = library.librarian
connect_destroy(lib, 'changed', self.__song_changed, player)
self._playback_error_dialog = None
player_sigs = [
('song-started', self.__song_started),
('paused', self.__update_paused, True),
('unpaused', self.__update_paused, False),
]
for sig in player_sigs:
connect_destroy(player, *sig)
# make sure we redraw all error indicators before opening
# a dialog (blocking the main loop), so connect after default handlers
connect_after_destroy(player, 'error', self.__player_error)
# connect after to let SongTracker update stats
connect_after_destroy(player, "song-ended", self.__song_ended)
targets = [("text/uri-list", Gtk.TargetFlags.OTHER_APP, DND_URI_LIST)]
targets = [Gtk.TargetEntry.new(*t) for t in targets]
self.drag_dest_set(
Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY)
self.connect('drag-data-received', self.__drag_data_received)
if not headless:
GLib.idle_add(self.__configure_scan_dirs, library)
if config.getboolean('library', 'refresh_on_start'):
self.__rebuild(None, False)
self.connect("key-press-event", self.__key_pressed, player)
self.connect("destroy", self.__destroy)
self.enable_window_tracking("quodlibet")
def set_as_osx_window(self, osx_app):
assert osx_app
menu = self.ui.get_widget("/Menu")
menu.hide()
osx_app.set_menu_bar(menu)
# Reparent some items to the "Application" menu
item = self.ui.get_widget('/Menu/Help/About')
osx_app.insert_app_menu_item(item, 0)
osx_app.insert_app_menu_item(Gtk.SeparatorMenuItem(), 1)
item = self.ui.get_widget('/Menu/Music/Preferences')
osx_app.insert_app_menu_item(item, 2)
quit_item = self.ui.get_widget('/Menu/Music/Quit')
quit_item.hide()
def get_osx_is_persistent(self):
return True
def __player_error(self, player, song, player_error):
# it's modal, but mmkeys etc. can still trigger new ones
if self._playback_error_dialog:
self._playback_error_dialog.destroy()
dialog = PlaybackErrorDialog(self, player_error)
self._playback_error_dialog = dialog
dialog.run()
self._playback_error_dialog = None
def __configure_scan_dirs(self, library):
"""Get user to configure scan dirs, if none is set up"""
if not get_scan_dirs() and not len(library) and \
quodlibet.is_first_session("quodlibet"):
print_d("Couldn't find any scan dirs")
resp = ConfirmLibDirSetup(self).run()
if resp == ConfirmLibDirSetup.RESPONSE_SETUP:
prefs = PreferencesWindow(self)
prefs.set_page("library")
prefs.show()
def __add_bookmark(self, librarian, player):
if player.song:
position = player.get_position() // 1000
bookmarks = player.song.bookmarks
new_mark = (position, _("Bookmark Name"))
if new_mark not in bookmarks:
bookmarks.append(new_mark)
player.song.bookmarks = bookmarks
def __edit_bookmarks(self, librarian, player):
if player.song:
window = EditBookmarks(self, librarian, player)
window.show()
def __key_pressed(self, widget, event, player):
if not player.song:
return
def seek_relative(seconds):
current = player.get_position()
current += seconds * 1000
current = min(player.song("~#length") * 1000 - 1, current)
current = max(0, current)
player.seek(current)
if qltk.is_accel(event, "<alt>Right"):
seek_relative(10)
return True
elif qltk.is_accel(event, "<alt>Left"):
seek_relative(-10)
return True
def __destroy(self, *args):
self.playlist.destroy()
# The tray icon plugin tries to unhide QL because it gets disabled
# on Ql exit. The window should stay hidden after destroy.
self.show = lambda: None
self.present = self.show
def __drag_data_received(self, widget, ctx, x, y, sel, tid, etime):
assert tid == DND_URI_LIST
uris = sel.get_uris()
dirs = []
error = False
for uri in uris:
try:
uri = URI(uri)
except ValueError:
continue
if uri.is_filename:
loc = os.path.normpath(uri.filename)
if os.path.isdir(loc):
dirs.append(loc)
else:
loc = os.path.realpath(loc)
if loc not in self.__library:
self.__library.add_filename(loc)
elif app.player.can_play_uri(uri):
if uri not in self.__library:
self.__library.add([RemoteFile(uri)])
else:
error = True
break
Gtk.drag_finish(ctx, not error, False, etime)
if error:
ErrorMessage(
self, _("Unable to add songs"),
_("%s uses an unsupported protocol.") % util.bold(uri)).run()
else:
if dirs:
copool.add(
self.__library.scan, dirs,
cofuncid="library", funcid="library")
def __songlist_key_press(self, songlist, event):
return self.browser.key_pressed(event)
def __songlist_drag_data_recv(self, view, *args):
if self.browser.can_reorder:
songs = view.get_songs()
self.browser.reordered(songs)
self.songlist.clear_sort()
def __show_or(self, widget, prop):
ssv = self.song_scroller.get_property('visible')
qxv = self.qexpander.get_property('visible')
self.songpane.set_property('visible', ssv or qxv)
if not ssv:
self.qexpander.set_expanded(True)
self.__expand_or(widget, prop)
def __expand_or(self, widget, prop):
if self.qexpander.get_property('expanded'):
self.songpane.set_property("position", self.__handle_position)
def __moved_pane_handle(self, widget, prop):
if self.qexpander.get_property('expanded'):
self.__handle_position = self.songpane.get_property("position")
def __qex_size_allocate(self, event, param=None):
if not self.qexpander.get_property('expanded'):
p_max = self.songpane.get_property("max-position")
p_cur = self.songpane.get_property("position")
if p_max != p_cur:
self.songpane.set_property("position", p_max)
def __create_menu(self, player, library):
ag = Gtk.ActionGroup.new('QuodLibetWindowActions')
actions = [
('Music', None, _("_Music")),
('AddFolders', Gtk.STOCK_ADD, _(u'_Add a Folder…'),
"<control>O", None, self.open_chooser),
('AddFiles', Gtk.STOCK_ADD, _(u'_Add a File…'),
None, None, self.open_chooser),
('AddLocation', Gtk.STOCK_ADD, _(u'_Add a Location…'),
None, None, self.open_location),
('BrowseLibrary', Gtk.STOCK_FIND, _('Open _Browser'), ""),
("Preferences", Gtk.STOCK_PREFERENCES, None, None, None,
self.__preferences),
("Plugins", Gtk.STOCK_EXECUTE, _("_Plugins"), None, None,
self.__plugins),
("Quit", Gtk.STOCK_QUIT, None, None, None,
lambda *x: self.destroy()),
("Control", None, _("_Control")),
("EditTags", Gtk.STOCK_PROPERTIES, _("Edit _Tags"), "", None,
self.__current_song_prop),
("Information", Gtk.STOCK_INFO, None, None, None,
self.__current_song_info),
("Jump", Gtk.STOCK_JUMP_TO, _("_Jump to Playing Song"),
"<control>J", None, self.__jump_to_current),
("View", None, _("_View")),
("Help", None, _("_Help")),
]
actions.append(("Previous", Gtk.STOCK_MEDIA_PREVIOUS, None,
"<control>comma", None, self.__previous_song))
actions.append(("PlayPause", Gtk.STOCK_MEDIA_PLAY, None,
"<control>space", None, self.__play_pause))
actions.append(("Next", Gtk.STOCK_MEDIA_NEXT, None,
"<control>period", None, self.__next_song))
ag.add_actions(actions)
act = Gtk.ToggleAction.new("StopAfter",
_("Stop After This Song"), None, "")
ag.add_action_with_accel(act, "<shift>space")
# access point for the tray icon
self.stop_after = act
act = Gtk.Action.new(
"AddBookmark", _("Add Bookmark"), None, Gtk.STOCK_ADD)
connect_obj(act, 'activate', self.__add_bookmark,
library.librarian, player)
ag.add_action_with_accel(act, "<ctrl>D")
act = Gtk.Action.new("EditBookmarks", _(u"Edit Bookmarks…"), None, "")
connect_obj(act, 'activate', self.__edit_bookmarks,
library.librarian, player)
ag.add_action_with_accel(act, "<ctrl>B")
act = Gtk.Action.new("About", None, None, Gtk.STOCK_ABOUT)
connect_obj(act, 'activate', self.__show_about, player)
ag.add_action_with_accel(act, None)
act = Gtk.Action.new(
"OnlineHelp", _("Online Help"), None, Gtk.STOCK_HELP)
def website_handler(*args):
util.website(const.ONLINE_HELP)
act.connect('activate', website_handler)
ag.add_action_with_accel(act, "F1")
act = Gtk.Action.new("SearchHelp", _("Search Help"), None, "")
def search_help_handler(*args):
util.website(const.SEARCH_HELP)
act.connect('activate', search_help_handler)
ag.add_action_with_accel(act, None)
act = Gtk.Action.new(
"RefreshLibrary", _("Re_fresh Library"), None, Gtk.STOCK_REFRESH)
act.connect('activate', self.__rebuild, False)
ag.add_action_with_accel(act, None)
ag.add_toggle_actions([
("SongList", None, _("Song _List"), None, None,
self.showhide_playlist,
config.getboolean("memory", "songlist"))])
ag.add_toggle_actions([
("Queue", None, _("_Queue"), None, None,
self.showhide_playqueue,
config.getboolean("memory", "queue"))])
view_actions = []
for i, Kind in enumerate(browsers.browsers):
action = "View" + Kind.__name__
label = Kind.accelerated_name
view_actions.append((action, None, label, None, None, i))
current = browsers.index(config.get("memory", "browser"))
def action_callback(view_action, current):
self.select_browser(view_action, current, library, player)
ag.add_radio_actions(
view_actions, current, action_callback,
None)
for Kind in browsers.browsers:
if not Kind.in_menu:
continue
action = "Browser" + Kind.__name__
label = Kind.accelerated_name
act = Gtk.Action.new(action, label, None, None)
def browser_activate(action, Kind):
LibraryBrowser.open(Kind, library, player)
act.connect('activate', browser_activate, Kind)
ag.add_action_with_accel(act, None)
ui = Gtk.UIManager()
ui.insert_action_group(ag, -1)
ui.add_ui_from_string(
MAIN_MENU % {"browsers": browsers.BrowseLibrary()})
self._filter_menu = FilterMenu(library, player, ui)
menustr = MENU % {
"views": browsers.ViewBrowser(),
}
ui.add_ui_from_string(menustr)
# Cute. So. UIManager lets you attach tooltips, but when they're
# for menu items, they just get ignored. So here I get to actually
# attach them.
ui.get_widget("/Menu/Music/RefreshLibrary").set_tooltip_text(
_("Check for changes in your library"))
return ui
def __show_about(self, player):
about = AboutQuodLibet(self, player)
about.run()
about.destroy()
def select_browser(self, activator, current, library, player,
restore=False):
if isinstance(current, Gtk.RadioAction):
current = current.get_current_value()
Browser = browsers.get(current)
config.set("memory", "browser", Browser.__name__)
if self.browser:
container = self.browser.__container
self.browser.unpack(container, self.songpane)
if self.browser.accelerators:
self.remove_accel_group(self.browser.accelerators)
container.destroy()
self.browser.destroy()
self.browser = Browser(library)
self.browser.connect('songs-selected',
self.__browser_cb, library, player)
self.browser.connect('songs-activated', self.__browser_activate)
if restore:
self.browser.restore()
self.browser.activate()
self.browser.finalize(restore)
if self.browser.can_reorder:
self.songlist.enable_drop()
elif self.browser.dropped:
self.songlist.enable_drop(False)
else:
self.songlist.disable_drop()
if self.browser.accelerators:
self.add_accel_group(self.browser.accelerators)
container = self.browser.__container = self.browser.pack(self.songpane)
player.replaygain_profiles[1] = self.browser.replaygain_profiles
player.volume = player.volume
self.__browserbox.add(container)
container.show()
self._filter_menu.set_browser(self.browser)
self.__hide_headers()
self.__refresh_size()
def __update_paused(self, player, paused):
menu = self.ui.get_widget("/Menu/Control/PlayPause")
if paused:
key = Gtk.STOCK_MEDIA_PLAY
else:
key = Gtk.STOCK_MEDIA_PAUSE
text = Gtk.stock_lookup(key).label
menu.get_image().set_from_stock(key, Gtk.IconSize.MENU)
menu.set_label(text)
menu.set_use_underline(True)
def __song_ended(self, player, song, stopped):
# check if the song should be removed base on the
# active filter of the current browser
active_filter = self.browser.active_filter
if song and active_filter and not active_filter(song):
iter_ = self.songlist.model.find(song)
if iter_:
self.songlist.remove_iters([iter_])
if self.stop_after.get_active():
player.paused = True
self.stop_after.set_active(False)
def __song_changed(self, library, songs, player):
if player.info in songs:
self.__update_title(player)
def __update_title(self, player):
song = player.info
title = "Quod Libet"
if song:
title = song.comma("~title~version~~people") + " - " + title
self.set_title(title)
def __song_started(self, player, song):
self.__update_title(player)
for wid in ["Jump", "Next", "EditTags", "Information",
"EditBookmarks", "AddBookmark", "StopAfter"]:
self.ui.get_widget(
'/Menu/Control/' + wid).set_sensitive(bool(song))
# don't jump on stream changes (player.info != player.song)
if song and player.song is song and not self.songlist._activated and \
config.getboolean("settings", "jump") and self.songlist.sourced:
self.__jump_to_current(False)
def __refresh_size(self):
ssv = self.song_scroller.get_property('visible')
qex = self.qexpander.get_property('visible')
if ssv or qex:
return
# Handle more later if needed..
if not isinstance(self.browser, Gtk.Box):
return
# If a child expands the browser will take the new space
for child in self.browser.get_children():
if self.browser.query_child_packing(child)[0]:
break
else:
# no expanding child, make the window smaller instead
width, height = self.get_size()
height = self.size_request().height
self.resize(width, height)
def showhide_playlist(self, toggle):
self.song_scroller.set_property('visible', toggle.get_active())
self.__refresh_size()
def showhide_playqueue(self, toggle):
self.qexpander.set_property('visible', toggle.get_active())
self.__refresh_size()
def __play_pause(self, *args):
if app.player.song is None:
app.player.reset()
else:
app.player.paused ^= True
def __jump_to_current(self, explicit, force_scroll=False):
"""Select/scroll to the current playing song in the playlist.
If it can't be found tell the browser to properly fill the playlist
with an appropriate selection containing the song.
explicit means that the jump request comes from the user and not
from an event like song-started.
force_scroll will ask the browser to refill the playlist in any case.
"""
def idle_jump_to(song, select):
ok = self.songlist.jump_to_song(song, select=select)
if ok:
self.songlist.grab_focus()
return False
song = app.player.song
# We are not playing a song
if song is None:
return
if not force_scroll:
ok = self.songlist.jump_to_song(song, select=explicit)
else:
assert explicit
ok = False
if ok:
self.songlist.grab_focus()
elif explicit:
# if we can't find it and the user requested it, try harder
self.browser.scroll(song)
# We need to wait until the browser has finished
# scrolling/filling and the songlist is ready.
# Not perfect, but works for now.
GLib.idle_add(
idle_jump_to, song, explicit, priority=GLib.PRIORITY_LOW)
def __next_song(self, *args):
app.player.next()
def __previous_song(self, *args):
app.player.previous()
def __rebuild(self, activator, force):
scan_library(self.__library, force)
# Set up the preferences window.
def __preferences(self, activator):
window = PreferencesWindow(self)
window.show()
def __plugins(self, activator):
window = PluginWindow(self)
window.show()
def open_location(self, action):
name = GetStringDialog(self, _("Add a Location"),
_("Enter the location of an audio file:"),
okbutton=Gtk.STOCK_ADD).run()
if name:
if not util.uri_is_valid(name):
ErrorMessage(
self, _("Unable to add location"),
_("%s is not a valid location.") % (
util.bold(util.escape(name)))).run()
elif not app.player.can_play_uri(name):
ErrorMessage(
self, _("Unable to add location"),
_("%s uses an unsupported protocol.") % (
util.bold(util.escape(name)))).run()
else:
if name not in self.__library:
self.__library.add([RemoteFile(name)])
def open_chooser(self, action):
last_dir = self.last_dir
if not os.path.exists(last_dir):
last_dir = const.HOME
class MusicFolderChooser(FolderChooser):
def __init__(self, parent, init_dir):
super(MusicFolderChooser, self).__init__(
parent, _("Add Music"), init_dir)
cb = Gtk.CheckButton(_("Watch this folder for new songs"))
# enable if no folders are being watched
cb.set_active(not get_scan_dirs())
cb.show()
self.set_extra_widget(cb)
def run(self):
fns = super(MusicFolderChooser, self).run()
cb = self.get_extra_widget()
return fns, cb.get_active()
class MusicFileChooser(FileChooser):
def __init__(self, parent, init_dir):
super(MusicFileChooser, self).__init__(
parent, _("Add Music"), formats.filter, init_dir)
if action.get_name() == "AddFolders":
dialog = MusicFolderChooser(self, last_dir)
fns, do_watch = dialog.run()
dialog.destroy()
if fns:
fns = map(glib2fsnative, fns)
# scan them
self.last_dir = fns[0]
copool.add(self.__library.scan, fns, funcid="library")
# add them as library scan directory
if do_watch:
dirs = get_scan_dirs()
for fn in fns:
if fn not in dirs:
dirs.append(fn)
set_scan_dirs(dirs)
else:
dialog = MusicFileChooser(self, last_dir)
fns = dialog.run()
dialog.destroy()
if fns:
fns = map(glib2fsnative, fns)
self.last_dir = os.path.dirname(fns[0])
for filename in map(os.path.realpath, fns):
self.__library.add_filename(filename)
def __songs_popup_menu(self, songlist):
path, col = songlist.get_cursor()
header = col.header_name
menu = self.songlist.Menu(header, self.browser, self.__library)
if menu is not None:
return self.songlist.popup_menu(menu, 0,
Gtk.get_current_event_time())
def __current_song_prop(self, *args):
song = app.player.song
if song:
librarian = self.__library.librarian
window = SongProperties(librarian, [song], parent=self)
window.show()
def __current_song_info(self, *args):
song = app.player.song
if song:
librarian = self.__library.librarian
window = Information(librarian, [song], self)
window.show()
def __browser_activate(self, browser):
app.player.reset()
def __browser_cb(self, browser, songs, sorted, library, player):
if browser.background:
bg = background_filter()
if bg:
songs = filter(bg, songs)
self.songlist.set_songs(songs, sorted)
# After the first time the browser activates, which should always
# happen if we start up and restore, restore the playing song.
# Because the browser has send us songs we can be sure it has
# registered all its libraries.
if self.__first_browser_set:
self.__first_browser_set = False
song = library.librarian.get(config.get("memory", "song"))
seek_pos = config.getint("memory", "seek", 0)
config.set("memory", "seek", 0)
if song is not None:
player.setup(self.playlist, song, seek_pos)
def __hide_headers(self, activator=None):
for column in self.songlist.get_columns():
if self.browser.headers is None:
column.set_visible(True)
else:
for tag in util.tagsplit(column.header_name):
if tag in self.browser.headers:
column.set_visible(True)
break
else:
column.set_visible(False)
def __cols_changed(self, songlist):
headers = [col.header_name for col in songlist.get_columns()]
try:
headers.remove('~current')
except ValueError:
pass
if len(headers) == len(get_columns()):
# Not an addition or removal (handled separately)
set_columns(headers)
SongList.headers = headers
def __make_query(self, query):
if self.browser.can_filter_text():
self.browser.filter_text(query.encode('utf-8'))
self.browser.activate()
def __set_time(self, info, songs):
i = len(songs)
length = sum(song.get("~#length", 0) for song in songs)
t = self.browser.statusbar(i) % {
'count': i, 'time': util.format_time_long(length)}
self.statusbar.set_default_text(t)
class QuodLibetWindow(Window, PersistentWindowMixin):
def __init__(self, library, player, headless=False, restore_cb=None):
super(QuodLibetWindow, self).__init__(dialog=False)
self.last_dir = get_home_dir()
self.__destroyed = False
self.__update_title(player)
self.set_default_size(550, 450)
main_box = Gtk.VBox()
self.add(main_box)
# create main menubar, load/restore accelerator groups
self.__library = library
ui = self.__create_menu(player, library)
accel_group = ui.get_accel_group()
self.add_accel_group(accel_group)
def scroll_and_jump(*args):
self.__jump_to_current(True, True)
keyval, mod = Gtk.accelerator_parse("<control><shift>J")
accel_group.connect(keyval, mod, 0, scroll_and_jump)
# dbus app menu
# Unity puts the app menu next to our menu bar. Since it only contains
# menu items also available in the menu bar itself, don't add it.
if not util.is_unity():
AppMenu(self, ui.get_action_groups()[0])
# custom accel map
accel_fn = os.path.join(quodlibet.get_user_dir(), "accels")
Gtk.AccelMap.load(accel_fn)
# save right away so we fill the file with example comments of all
# accels
Gtk.AccelMap.save(accel_fn)
menubar = ui.get_widget("/Menu")
# Since https://git.gnome.org/browse/gtk+/commit/?id=b44df22895c79
# toplevel menu items show an empty 16x16 image. While we don't
# need image items there UIManager creates them by default.
# Work around by removing the empty GtkImages
for child in menubar.get_children():
if isinstance(child, Gtk.ImageMenuItem):
child.set_image(None)
main_box.pack_start(menubar, False, True, 0)
# get the playlist up before other stuff
self.songlist = MainSongList(library, player)
self.songlist.show_all()
self.songlist.connect("key-press-event", self.__songlist_key_press)
self.songlist.connect_after('drag-data-received',
self.__songlist_drag_data_recv)
self.song_scroller = SongListScroller(
ui.get_widget("/Menu/View/SongList"))
self.song_scroller.add(self.songlist)
self.qexpander = QueueExpander(ui.get_widget("/Menu/View/Queue"),
library, player)
self.playlist = PlaylistMux(player, self.qexpander.model,
self.songlist.model)
top_bar = TopBar(self, player, library)
main_box.pack_start(top_bar, False, True, 0)
self.top_bar = top_bar
self.__browserbox = Align(bottom=3)
main_box.pack_start(self.__browserbox, True, True, 0)
statusbox = StatusBarBox(self.songlist.model, player)
self.order = statusbox.order
self.repeat = statusbox.repeat
self.statusbar = statusbox.statusbar
main_box.pack_start(Align(statusbox, border=3, top=-3, right=3), False,
True, 0)
self.songpane = ConfigRVPaned("memory", "queue_position", 0.75)
self.songpane.pack1(self.song_scroller, resize=True, shrink=False)
self.songpane.pack2(self.qexpander, resize=True, shrink=False)
self.__handle_position = self.songpane.get_property("position")
def songpane_button_press_cb(pane, event):
"""If we start to drag the pane handle while the
queue expander is unexpanded, expand it and move the handle
to the bottom, so we can 'drag' the queue out
"""
if event.window != pane.get_handle_window():
return False
if not self.qexpander.get_expanded():
self.qexpander.set_expanded(True)
pane.set_relative(1.0)
return False
self.songpane.connect("button-press-event", songpane_button_press_cb)
self.song_scroller.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::expanded', self.__expand_or)
self.qexpander.connect('draw', self.__qex_size_allocate)
self.songpane.connect('notify', self.__moved_pane_handle)
try:
orders = []
for e in config.getstringlist('memory', 'sortby', []):
orders.append((e[1:], int(e[0])))
except ValueError:
pass
else:
self.songlist.set_sort_orders(orders)
self.browser = None
self.ui = ui
main_box.show_all()
self._playback_error_dialog = None
connect_destroy(player, 'song-started', self.__song_started)
connect_destroy(player, 'paused', self.__update_paused, True)
connect_destroy(player, 'unpaused', self.__update_paused, False)
# make sure we redraw all error indicators before opening
# a dialog (blocking the main loop), so connect after default handlers
connect_after_destroy(player, 'error', self.__player_error)
# connect after to let SongTracker update stats
connect_after_destroy(player, "song-ended", self.__song_ended)
# set at least the playlist. the song should be restored
# after the browser emits the song list
player.setup(self.playlist, None, 0)
self.__restore_cb = restore_cb
self.__first_browser_set = True
restore_browser = not headless
try:
self.select_browser(self, config.get("memory", "browser"), library,
player, restore_browser)
except:
config.set("memory", "browser", browsers.name(0))
config.save()
raise
self.showhide_playlist(ui.get_widget("/Menu/View/SongList"))
self.showhide_playqueue(ui.get_widget("/Menu/View/Queue"))
self.songlist.connect('popup-menu', self.__songs_popup_menu)
self.songlist.connect('columns-changed', self.__cols_changed)
self.songlist.connect('columns-changed', self.__hide_headers)
self.songlist.info.connect("changed", self.__set_time)
lib = library.librarian
connect_destroy(lib, 'changed', self.__song_changed, player)
targets = [("text/uri-list", Gtk.TargetFlags.OTHER_APP, DND_URI_LIST)]
targets = [Gtk.TargetEntry.new(*t) for t in targets]
self.drag_dest_set(Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY)
self.connect('drag-data-received', self.__drag_data_received)
if not headless:
on_first_map(self, self.__configure_scan_dirs, library)
if config.getboolean('library', 'refresh_on_start'):
self.__rebuild(None, False)
self.connect("key-press-event", self.__key_pressed, player)
self.connect("destroy", self.__destroy)
self.enable_window_tracking("quodlibet")
def set_as_osx_window(self, osx_app):
assert osx_app
menu = self.ui.get_widget("/Menu")
menu.hide()
osx_app.set_menu_bar(menu)
# Reparent some items to the "Application" menu
item = self.ui.get_widget('/Menu/Help/About')
osx_app.insert_app_menu_item(item, 0)
osx_app.insert_app_menu_item(Gtk.SeparatorMenuItem(), 1)
item = self.ui.get_widget('/Menu/Music/Preferences')
osx_app.insert_app_menu_item(item, 2)
quit_item = self.ui.get_widget('/Menu/Music/Quit')
quit_item.hide()
def get_osx_is_persistent(self):
return True
def __player_error(self, player, song, player_error):
# it's modal, but mmkeys etc. can still trigger new ones
if self._playback_error_dialog:
self._playback_error_dialog.destroy()
dialog = PlaybackErrorDialog(self, player_error)
self._playback_error_dialog = dialog
dialog.run()
self._playback_error_dialog = None
def __configure_scan_dirs(self, library):
"""Get user to configure scan dirs, if none is set up"""
if not get_scan_dirs() and not len(library) and \
quodlibet.is_first_session("quodlibet"):
print_d("Couldn't find any scan dirs")
resp = ConfirmLibDirSetup(self).run()
if resp == ConfirmLibDirSetup.RESPONSE_SETUP:
prefs = PreferencesWindow(self)
prefs.set_page("library")
prefs.show()
def __add_bookmark(self, librarian, player):
if player.song:
position = player.get_position() // 1000
bookmarks = player.song.bookmarks
new_mark = (position, _("Bookmark Name"))
if new_mark not in bookmarks:
bookmarks.append(new_mark)
player.song.bookmarks = bookmarks
def __edit_bookmarks(self, librarian, player):
if player.song:
window = EditBookmarks(self, librarian, player)
window.show()
def __key_pressed(self, widget, event, player):
if not player.song:
return
def seek_relative(seconds):
current = player.get_position()
current += seconds * 1000
current = min(player.song("~#length") * 1000 - 1, current)
current = max(0, current)
player.seek(current)
if qltk.is_accel(event, "<alt>Right"):
seek_relative(10)
return True
elif qltk.is_accel(event, "<alt>Left"):
seek_relative(-10)
return True
def __destroy(self, *args):
self.playlist.destroy()
# The tray icon plugin tries to unhide QL because it gets disabled
# on Ql exit. The window should stay hidden after destroy.
self.show = lambda: None
self.present = self.show
def __drag_data_received(self, widget, ctx, x, y, sel, tid, etime):
assert tid == DND_URI_LIST
uris = sel.get_uris()
dirs = []
error = False
for uri in uris:
try:
uri = URI(uri)
except ValueError:
continue
if uri.is_filename:
loc = os.path.normpath(uri.filename)
if os.path.isdir(loc):
dirs.append(loc)
else:
loc = os.path.realpath(loc)
if loc not in self.__library:
self.__library.add_filename(loc)
elif app.player.can_play_uri(uri):
if uri not in self.__library:
self.__library.add([RemoteFile(uri)])
else:
error = True
break
Gtk.drag_finish(ctx, not error, False, etime)
if error:
ErrorMessage(
self, _("Unable to add songs"),
_("%s uses an unsupported protocol.") % util.bold(uri)).run()
else:
if dirs:
copool.add(self.__library.scan,
dirs,
cofuncid="library",
funcid="library")
def __songlist_key_press(self, songlist, event):
return self.browser.key_pressed(event)
def __songlist_drag_data_recv(self, view, *args):
if self.browser.can_reorder:
songs = view.get_songs()
self.browser.reordered(songs)
self.songlist.clear_sort()
def __show_or(self, widget, prop):
ssv = self.song_scroller.get_property('visible')
qxv = self.qexpander.get_property('visible')
self.songpane.set_property('visible', ssv or qxv)
if not ssv:
self.qexpander.set_expanded(True)
self.__expand_or(widget, prop)
def __expand_or(self, widget, prop):
if self.qexpander.get_property('expanded'):
self.songpane.set_property("position", self.__handle_position)
def __moved_pane_handle(self, widget, prop):
if self.qexpander.get_property('expanded'):
self.__handle_position = self.songpane.get_property("position")
def __qex_size_allocate(self, event, param=None):
if not self.qexpander.get_property('expanded'):
p_max = self.songpane.get_property("max-position")
p_cur = self.songpane.get_property("position")
if p_max != p_cur:
self.songpane.set_property("position", p_max)
def __create_menu(self, player, library):
ag = Gtk.ActionGroup.new('QuodLibetWindowActions')
actions = [
('Music', None, _("_Music")),
('AddFolders', Gtk.STOCK_ADD, _(u'_Add a Folder…'), "<control>O",
None, self.open_chooser),
('AddFiles', Gtk.STOCK_ADD, _(u'_Add a File…'), None, None,
self.open_chooser),
('AddLocation', Gtk.STOCK_ADD, _(u'_Add a Location…'), None, None,
self.open_location),
('BrowseLibrary', Gtk.STOCK_FIND, _('Open _Browser'), ""),
("Preferences", Gtk.STOCK_PREFERENCES, None, None, None,
self.__preferences),
("Plugins", Gtk.STOCK_EXECUTE, _("_Plugins"), None, None,
self.__plugins),
("Quit", Gtk.STOCK_QUIT, None, None, None,
lambda *x: self.destroy()),
("Control", None, _("_Control")),
("EditTags", Gtk.STOCK_PROPERTIES, _("Edit _Tags"), "", None,
self.__current_song_prop),
("Information", Gtk.STOCK_INFO, None, None, None,
self.__current_song_info),
("Jump", Gtk.STOCK_JUMP_TO, _("_Jump to Playing Song"),
"<control>J", None, self.__jump_to_current),
("View", None, _("_View")),
("Help", None, _("_Help")),
]
actions.append(("Previous", Gtk.STOCK_MEDIA_PREVIOUS, None,
"<control>comma", None, self.__previous_song))
actions.append(("PlayPause", Gtk.STOCK_MEDIA_PLAY, None,
"<control>space", None, self.__play_pause))
actions.append(("Next", Gtk.STOCK_MEDIA_NEXT, None, "<control>period",
None, self.__next_song))
ag.add_actions(actions)
act = Gtk.ToggleAction.new("StopAfter", _("Stop After This Song"),
None, "")
ag.add_action_with_accel(act, "<shift>space")
# access point for the tray icon
self.stop_after = act
act = Gtk.Action.new("AddBookmark", _("Add Bookmark"), None,
Gtk.STOCK_ADD)
connect_obj(act, 'activate', self.__add_bookmark, library.librarian,
player)
ag.add_action_with_accel(act, "<ctrl>D")
act = Gtk.Action.new("EditBookmarks", _(u"Edit Bookmarks…"), None, "")
connect_obj(act, 'activate', self.__edit_bookmarks, library.librarian,
player)
ag.add_action_with_accel(act, "<ctrl>B")
act = Gtk.Action.new("About", None, None, Gtk.STOCK_ABOUT)
connect_obj(act, 'activate', self.__show_about, player)
ag.add_action_with_accel(act, None)
act = Gtk.Action.new("OnlineHelp", _("Online Help"), None,
Gtk.STOCK_HELP)
def website_handler(*args):
util.website(const.ONLINE_HELP)
act.connect('activate', website_handler)
ag.add_action_with_accel(act, "F1")
act = Gtk.Action.new("SearchHelp", _("Search Help"), None, "")
def search_help_handler(*args):
util.website(const.SEARCH_HELP)
act.connect('activate', search_help_handler)
ag.add_action_with_accel(act, None)
act = Gtk.Action.new("RefreshLibrary", _("Re_fresh Library"), None,
Gtk.STOCK_REFRESH)
act.connect('activate', self.__rebuild, False)
ag.add_action_with_accel(act, None)
ag.add_toggle_actions([("SongList", None, _("Song _List"), None, None,
self.showhide_playlist,
config.getboolean("memory", "songlist"))])
ag.add_toggle_actions([("Queue", None, _("_Queue"), None, None,
self.showhide_playqueue,
config.getboolean("memory", "queue"))])
view_actions = []
for i, Kind in enumerate(browsers.browsers):
action = "View" + Kind.__name__
label = Kind.accelerated_name
view_actions.append((action, None, label, None, None, i))
current = browsers.index(config.get("memory", "browser"))
def action_callback(view_action, current):
self.select_browser(view_action, current, library, player)
ag.add_radio_actions(view_actions, current, action_callback, None)
for Kind in browsers.browsers:
if not Kind.in_menu:
continue
action = "Browser" + Kind.__name__
label = Kind.accelerated_name
act = Gtk.Action.new(action, label, None, None)
def browser_activate(action, Kind):
LibraryBrowser.open(Kind, library, player)
act.connect('activate', browser_activate, Kind)
ag.add_action_with_accel(act, None)
ui = Gtk.UIManager()
ui.insert_action_group(ag, -1)
ui.add_ui_from_string(MAIN_MENU %
{"browsers": browsers.BrowseLibrary()})
self._filter_menu = FilterMenu(library, player, ui)
menustr = MENU % {
"views": browsers.ViewBrowser(),
}
ui.add_ui_from_string(menustr)
# Cute. So. UIManager lets you attach tooltips, but when they're
# for menu items, they just get ignored. So here I get to actually
# attach them.
ui.get_widget("/Menu/Music/RefreshLibrary").set_tooltip_text(
_("Check for changes in your library"))
return ui
def __show_about(self, player):
about = AboutQuodLibet(self, player)
about.run()
about.destroy()
def select_browser(self,
activator,
current,
library,
player,
restore=False):
if isinstance(current, Gtk.RadioAction):
current = current.get_current_value()
Browser = browsers.get(current)
config.set("memory", "browser", Browser.__name__)
if self.browser:
if not (self.browser.uses_main_library
and Browser.uses_main_library):
self.songlist.clear()
container = self.browser.__container
self.browser.unpack(container, self.songpane)
if self.browser.accelerators:
self.remove_accel_group(self.browser.accelerators)
container.destroy()
self.browser.destroy()
self.browser = Browser(library)
self.browser.connect('songs-selected', self.__browser_cb, library,
player)
self.browser.connect('songs-activated', self.__browser_activate)
if restore:
self.browser.restore()
self.browser.activate()
self.browser.finalize(restore)
if self.browser.can_reorder:
self.songlist.enable_drop()
elif self.browser.dropped:
self.songlist.enable_drop(False)
else:
self.songlist.disable_drop()
if self.browser.accelerators:
self.add_accel_group(self.browser.accelerators)
container = self.browser.__container = self.browser.pack(self.songpane)
player.replaygain_profiles[1] = self.browser.replaygain_profiles
player.reset_replaygain()
self.__browserbox.add(container)
container.show()
self._filter_menu.set_browser(self.browser)
self.__hide_headers()
self.__refresh_size()
def __update_paused(self, player, paused):
menu = self.ui.get_widget("/Menu/Control/PlayPause")
if paused:
key = Gtk.STOCK_MEDIA_PLAY
else:
key = Gtk.STOCK_MEDIA_PAUSE
text = Gtk.stock_lookup(key).label
menu.get_image().set_from_stock(key, Gtk.IconSize.MENU)
menu.set_label(text)
menu.set_use_underline(True)
def __song_ended(self, player, song, stopped):
# check if the song should be removed base on the
# active filter of the current browser
active_filter = self.browser.active_filter
if song and active_filter and not active_filter(song):
iter_ = self.songlist.model.find(song)
if iter_:
self.songlist.remove_iters([iter_])
if self.stop_after.get_active():
player.paused = True
self.stop_after.set_active(False)
def __song_changed(self, library, songs, player):
if player.info in songs:
self.__update_title(player)
def __update_title(self, player):
song = player.info
title = "Quod Libet"
if song:
title = song.comma("~title~version~~people") + " - " + title
self.set_title(title)
def __song_started(self, player, song):
self.__update_title(player)
for wid in [
"Jump", "Next", "EditTags", "Information", "EditBookmarks",
"AddBookmark", "StopAfter"
]:
self.ui.get_widget('/Menu/Control/' + wid).set_sensitive(
bool(song))
# don't jump on stream changes (player.info != player.song)
if song and player.song is song and not self.songlist._activated and \
config.getboolean("settings", "jump") and self.songlist.sourced:
self.__jump_to_current(False)
def __refresh_size(self):
ssv = self.song_scroller.get_property('visible')
qex = self.qexpander.get_property('visible')
if ssv or qex:
return
# Handle more later if needed..
if not isinstance(self.browser, Gtk.Box):
return
# If a child expands the browser will take the new space
for child in self.browser.get_children():
if self.browser.query_child_packing(child)[0]:
break
else:
# no expanding child, make the window smaller instead
width, height = self.get_size()
height = self.size_request().height
self.resize(width, height)
def showhide_playlist(self, toggle):
self.song_scroller.set_property('visible', toggle.get_active())
self.__refresh_size()
def showhide_playqueue(self, toggle):
self.qexpander.set_property('visible', toggle.get_active())
self.__refresh_size()
def __play_pause(self, *args):
if app.player.song is None:
app.player.reset()
else:
app.player.paused ^= True
def __jump_to_current(self, explicit, force_scroll=False):
"""Select/scroll to the current playing song in the playlist.
If it can't be found tell the browser to properly fill the playlist
with an appropriate selection containing the song.
explicit means that the jump request comes from the user and not
from an event like song-started.
force_scroll will ask the browser to refill the playlist in any case.
"""
def idle_jump_to(song, select):
ok = self.songlist.jump_to_song(song, select=select)
if ok:
self.songlist.grab_focus()
return False
song = app.player.song
# We are not playing a song
if song is None:
return
if not force_scroll:
ok = self.songlist.jump_to_song(song, select=explicit)
else:
assert explicit
ok = False
if ok:
self.songlist.grab_focus()
elif explicit:
# if we can't find it and the user requested it, try harder
self.browser.scroll(song)
# We need to wait until the browser has finished
# scrolling/filling and the songlist is ready.
# Not perfect, but works for now.
GLib.idle_add(idle_jump_to,
song,
explicit,
priority=GLib.PRIORITY_LOW)
def __next_song(self, *args):
app.player.next()
def __previous_song(self, *args):
app.player.previous()
def __rebuild(self, activator, force):
scan_library(self.__library, force)
# Set up the preferences window.
def __preferences(self, activator):
window = PreferencesWindow(self)
window.show()
def __plugins(self, activator):
window = PluginWindow(self)
window.show()
def open_location(self, action):
name = GetStringDialog(self,
_("Add a Location"),
_("Enter the location of an audio file:"),
okbutton=Gtk.STOCK_ADD).run()
if name:
if not util.uri_is_valid(name):
ErrorMessage(
self, _("Unable to add location"),
_("%s is not a valid location.") %
(util.bold(util.escape(name)))).run()
elif not app.player.can_play_uri(name):
ErrorMessage(
self, _("Unable to add location"),
_("%s uses an unsupported protocol.") %
(util.bold(util.escape(name)))).run()
else:
if name not in self.__library:
self.__library.add([RemoteFile(name)])
def open_chooser(self, action):
last_dir = self.last_dir
if not os.path.exists(last_dir):
last_dir = get_home_dir()
class MusicFolderChooser(FolderChooser):
def __init__(self, parent, init_dir):
super(MusicFolderChooser,
self).__init__(parent, _("Add Music"), init_dir)
cb = Gtk.CheckButton(_("Watch this folder for new songs"))
# enable if no folders are being watched
cb.set_active(not get_scan_dirs())
cb.show()
self.set_extra_widget(cb)
def run(self):
fns = super(MusicFolderChooser, self).run()
cb = self.get_extra_widget()
return fns, cb.get_active()
class MusicFileChooser(FileChooser):
def __init__(self, parent, init_dir):
super(MusicFileChooser,
self).__init__(parent, _("Add Music"), formats.filter,
init_dir)
if action.get_name() == "AddFolders":
dialog = MusicFolderChooser(self, last_dir)
fns, do_watch = dialog.run()
dialog.destroy()
if fns:
fns = map(glib2fsnative, fns)
# scan them
self.last_dir = fns[0]
copool.add(self.__library.scan,
fns,
cofuncid="library",
funcid="library")
# add them as library scan directory
if do_watch:
dirs = get_scan_dirs()
for fn in fns:
if fn not in dirs:
dirs.append(fn)
set_scan_dirs(dirs)
else:
dialog = MusicFileChooser(self, last_dir)
fns = dialog.run()
dialog.destroy()
if fns:
fns = map(glib2fsnative, fns)
self.last_dir = os.path.dirname(fns[0])
for filename in map(os.path.realpath, fns):
self.__library.add_filename(filename)
def __songs_popup_menu(self, songlist):
path, col = songlist.get_cursor()
header = col.header_name
menu = self.songlist.Menu(header, self.browser, self.__library)
if menu is not None:
return self.songlist.popup_menu(menu, 0,
Gtk.get_current_event_time())
def __current_song_prop(self, *args):
song = app.player.song
if song:
librarian = self.__library.librarian
window = SongProperties(librarian, [song], parent=self)
window.show()
def __current_song_info(self, *args):
song = app.player.song
if song:
librarian = self.__library.librarian
window = Information(librarian, [song], self)
window.show()
def __browser_activate(self, browser):
app.player.reset()
def __browser_cb(self, browser, songs, sorted, library, player):
if browser.background:
bg = background_filter()
if bg:
songs = filter(bg, songs)
self.songlist.set_songs(songs, sorted)
# After the first time the browser activates, which should always
# happen if we start up and restore, restore the playing song.
# Because the browser has send us songs we can be sure it has
# registered all its libraries.
if self.__first_browser_set:
self.__first_browser_set = False
song = library.librarian.get(config.get("memory", "song"))
seek_pos = config.getfloat("memory", "seek", 0)
config.set("memory", "seek", 0)
if song is not None:
player.setup(self.playlist, song, seek_pos)
if self.__restore_cb:
self.__restore_cb()
self.__restore_cb = None
def __hide_headers(self, activator=None):
for column in self.songlist.get_columns():
if self.browser.headers is None:
column.set_visible(True)
else:
for tag in util.tagsplit(column.header_name):
if tag in self.browser.headers:
column.set_visible(True)
break
else:
column.set_visible(False)
def __cols_changed(self, songlist):
headers = [col.header_name for col in songlist.get_columns()]
try:
headers.remove('~current')
except ValueError:
pass
if len(headers) == len(get_columns()):
# Not an addition or removal (handled separately)
set_columns(headers)
SongList.headers = headers
def __make_query(self, query):
if self.browser.can_filter_text():
self.browser.filter_text(query.encode('utf-8'))
self.browser.activate()
def __set_time(self, info, songs):
i = len(songs)
length = sum(song.get("~#length", 0) for song in songs)
t = self.browser.statusbar(i) % {
'count': i,
'time': util.format_time_long(length)
}
self.statusbar.set_default_text(t)
class QuodLibetWindow(Window, PersistentWindowMixin, AppWindow):
def __init__(self, library, player, headless=False, restore_cb=None):
super().__init__(dialog=False)
self.__destroyed = False
self.__update_title(player)
self.set_default_size(600, 480)
main_box = Gtk.VBox()
self.add(main_box)
self.side_book = qltk.Notebook()
# get the playlist up before other stuff
self.songlist = MainSongList(library, player)
self.songlist.connect("key-press-event", self.__songlist_key_press)
self.songlist.connect_after('drag-data-received',
self.__songlist_drag_data_recv)
self.song_scroller = ScrolledWindow()
self.song_scroller.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
self.song_scroller.set_shadow_type(Gtk.ShadowType.IN)
self.song_scroller.add(self.songlist)
self.qexpander = QueueExpander(library, player)
self.qexpander.set_no_show_all(True)
self.qexpander.set_visible(config.getboolean("memory", "queue"))
def on_queue_visible(qex, param):
config.set("memory", "queue", str(qex.get_visible()))
self.qexpander.connect("notify::visible", on_queue_visible)
self.playlist = PlaylistMux(player, self.qexpander.model,
self.songlist.model)
self.__player = player
# create main menubar, load/restore accelerator groups
self.__library = library
ui = self.__create_menu(player, library)
accel_group = ui.get_accel_group()
self.add_accel_group(accel_group)
def scroll_and_jump(*args):
self.__jump_to_current(True, None, True)
keyval, mod = Gtk.accelerator_parse("<Primary><shift>J")
accel_group.connect(keyval, mod, 0, scroll_and_jump)
# custom accel map
accel_fn = os.path.join(quodlibet.get_user_dir(), "accels")
Gtk.AccelMap.load(accel_fn)
# save right away so we fill the file with example comments of all
# accels
Gtk.AccelMap.save(accel_fn)
menubar = ui.get_widget("/Menu")
# Since https://git.gnome.org/browse/gtk+/commit/?id=b44df22895c79
# toplevel menu items show an empty 16x16 image. While we don't
# need image items there UIManager creates them by default.
# Work around by removing the empty GtkImages
for child in menubar.get_children():
if isinstance(child, Gtk.ImageMenuItem):
child.set_image(None)
main_box.pack_start(menubar, False, True, 0)
top_bar = TopBar(self, player, library)
main_box.pack_start(top_bar, False, True, 0)
self.top_bar = top_bar
self.__browserbox = Align(bottom=3)
self.__paned = paned = ConfigRHPaned("memory", "sidebar_pos", 0.25)
paned.pack1(self.__browserbox, resize=True)
# We'll pack2 when necessary (when the first sidebar plugin is set up)
main_box.pack_start(paned, True, True, 0)
play_order = PlayOrderWidget(self.songlist.model, player)
statusbox = StatusBarBox(play_order, self.qexpander)
self.order = play_order
self.statusbar = statusbox.statusbar
main_box.pack_start(Align(statusbox, border=3, top=-3), False, True, 0)
self.songpane = SongListPaned(self.song_scroller, self.qexpander)
self.songpane.show_all()
try:
orders = []
for e in config.getstringlist('memory', 'sortby', []):
orders.append((e[1:], int(e[0])))
except ValueError:
pass
else:
self.songlist.set_sort_orders(orders)
self.browser = None
self.ui = ui
main_box.show_all()
self._playback_error_dialog = None
connect_destroy(player, 'song-started', self.__song_started)
connect_destroy(player, 'paused', self.__update_paused, True)
connect_destroy(player, 'unpaused', self.__update_paused, False)
# make sure we redraw all error indicators before opening
# a dialog (blocking the main loop), so connect after default handlers
connect_after_destroy(player, 'error', self.__player_error)
# connect after to let SongTracker update stats
connect_after_destroy(player, "song-ended", self.__song_ended)
# set at least the playlist. the song should be restored
# after the browser emits the song list
player.setup(self.playlist, None, 0)
self.__restore_cb = restore_cb
self.__first_browser_set = True
restore_browser = not headless
try:
self._select_browser(self, config.get("memory", "browser"),
library, player, restore_browser)
except:
config.set("memory", "browser", browsers.name(browsers.default))
config.save()
raise
self.songlist.connect('popup-menu', self.__songs_popup_menu)
self.songlist.connect('columns-changed', self.__cols_changed)
self.songlist.connect('columns-changed', self.__hide_headers)
self.songlist.info.connect("changed", self.__set_totals)
lib = library.librarian
connect_destroy(lib, 'changed', self.__song_changed, player)
targets = [("text/uri-list", Gtk.TargetFlags.OTHER_APP, DND_URI_LIST)]
targets = [Gtk.TargetEntry.new(*t) for t in targets]
self.drag_dest_set(Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY)
self.connect('drag-data-received', self.__drag_data_received)
if not headless:
on_first_map(self, self.__configure_scan_dirs, library)
if config.getboolean('library', 'refresh_on_start'):
self.__rebuild(None, False)
self.connect("key-press-event", self.__key_pressed, player)
self.connect("destroy", self.__destroy)
self.enable_window_tracking("quodlibet")
def hide_side_book(self):
self.side_book.hide()
def add_sidebar(self, box, name):
vbox = Gtk.Box(margin=0)
vbox.pack_start(box, True, True, 0)
vbox.show()
if self.side_book_empty:
self.add_sidebar_to_layout(self.side_book)
self.side_book.append_page(vbox, label=name)
self.side_book.set_tab_detachable(vbox, False)
self.side_book.show_all()
return vbox
def remove_sidebar(self, widget):
self.side_book.remove_page(self.side_book.page_num(widget))
if self.side_book_empty:
print_d("Hiding sidebar")
self.__paned.remove(self.__paned.get_children()[1])
def add_sidebar_to_layout(self, widget):
print_d("Recreating sidebar")
align = Align(widget, top=6, bottom=3)
self.__paned.pack2(align, shrink=True)
align.show_all()
@property
def side_book_empty(self):
return not self.side_book.get_children()
def set_seekbar_widget(self, widget):
"""Add an alternative seek bar widget.
Args:
widget (Gtk.Widget): a new widget or None to remove the current one
"""
self.top_bar.set_seekbar_widget(widget)
def set_as_osx_window(self, osx_app):
assert osx_app
self._dock_menu = DockMenu(app)
osx_app.set_dock_menu(self._dock_menu)
menu = self.ui.get_widget("/Menu")
menu.hide()
osx_app.set_menu_bar(menu)
# Reparent some items to the "Application" menu
item = self.ui.get_widget('/Menu/Help/About')
osx_app.insert_app_menu_item(item, 0)
osx_app.insert_app_menu_item(Gtk.SeparatorMenuItem(), 1)
item = self.ui.get_widget('/Menu/File/Preferences')
osx_app.insert_app_menu_item(item, 2)
quit_item = self.ui.get_widget('/Menu/File/Quit')
quit_item.hide()
def get_is_persistent(self):
return True
def open_file(self, filename):
assert isinstance(filename, fsnative)
song = self.__library.add_filename(filename, add=False)
if song is not None:
if self.__player.go_to(song):
self.__player.paused = False
return True
else:
return False
def __player_error(self, player, song, player_error):
# it's modal, but mmkeys etc. can still trigger new ones
if self._playback_error_dialog:
self._playback_error_dialog.destroy()
dialog = PlaybackErrorDialog(self, player_error)
self._playback_error_dialog = dialog
dialog.run()
self._playback_error_dialog = None
def __configure_scan_dirs(self, library):
"""Get user to configure scan dirs, if none is set up"""
if not get_scan_dirs() and not len(library) and \
quodlibet.is_first_session("quodlibet"):
print_d("Couldn't find any scan dirs")
resp = ConfirmLibDirSetup(self).run()
if resp == ConfirmLibDirSetup.RESPONSE_SETUP:
prefs = PreferencesWindow(self)
prefs.set_page("library")
prefs.show()
def __keyboard_shortcuts(self, action):
show_shortcuts(self)
def __edit_bookmarks(self, librarian, player):
if player.song:
window = EditBookmarks(self, librarian, player)
window.show()
def __key_pressed(self, widget, event, player):
if not player.song:
return
def seek_relative(seconds):
current = player.get_position()
current += seconds * 1000
current = min(player.song("~#length") * 1000 - 1, current)
current = max(0, current)
player.seek(current)
if qltk.is_accel(event, "<alt>Right"):
seek_relative(10)
return True
elif qltk.is_accel(event, "<alt>Left"):
seek_relative(-10)
return True
def __destroy(self, *args):
self.playlist.destroy()
# The tray icon plugin tries to unhide QL because it gets disabled
# on Ql exit. The window should stay hidden after destroy.
self.show = lambda: None
self.present = self.show
def __drag_data_received(self, widget, ctx, x, y, sel, tid, etime):
assert tid == DND_URI_LIST
uris = sel.get_uris()
dirs = []
error = False
for uri in uris:
try:
filename = uri2fsn(uri)
except ValueError:
filename = None
if filename is not None:
loc = os.path.normpath(filename)
if os.path.isdir(loc):
dirs.append(loc)
else:
loc = os.path.realpath(loc)
if loc not in self.__library:
self.__library.add_filename(loc)
elif app.player.can_play_uri(uri):
if uri not in self.__library:
self.__library.add([RemoteFile(uri)])
else:
error = True
break
Gtk.drag_finish(ctx, not error, False, etime)
if error:
ErrorMessage(
self, _("Unable to add songs"),
_("%s uses an unsupported protocol.") % util.bold(uri)).run()
else:
if dirs:
copool.add(self.__library.scan,
dirs,
cofuncid="library",
funcid="library")
def __songlist_key_press(self, songlist, event):
return self.browser.key_pressed(event)
def __songlist_drag_data_recv(self, view, *args):
if self.browser.can_reorder:
songs = view.get_songs()
self.browser.reordered(songs)
self.songlist.clear_sort()
def __create_menu(self, player, library):
def add_view_items(ag):
act = Action(name="Information",
label=_('_Information'),
icon_name=Icons.DIALOG_INFORMATION)
act.connect('activate', self.__current_song_info)
ag.add_action(act)
act = Action(name="Jump",
label=_('_Jump to Playing Song'),
icon_name=Icons.GO_JUMP)
self.__jump_to_current(True, None, True)
act.connect('activate', self.__jump_to_current)
ag.add_action_with_accel(act, "<Primary>J")
def add_top_level_items(ag):
ag.add_action(Action(name="File", label=_("_File")))
ag.add_action(Action(name="Song", label=_("_Song")))
ag.add_action(Action(name="View", label=_('_View')))
ag.add_action(Action(name="Browse", label=_("_Browse")))
ag.add_action(Action(name="Control", label=_('_Control')))
ag.add_action(Action(name="Help", label=_('_Help')))
ag = Gtk.ActionGroup.new('QuodLibetWindowActions')
add_top_level_items(ag)
add_view_items(ag)
act = Action(name="AddFolders",
label=_(u'_Add a Folder…'),
icon_name=Icons.LIST_ADD)
act.connect('activate', self.open_chooser)
ag.add_action_with_accel(act, "<Primary>O")
act = Action(name="AddFiles",
label=_(u'_Add a File…'),
icon_name=Icons.LIST_ADD)
act.connect('activate', self.open_chooser)
ag.add_action(act)
act = Action(name="AddLocation",
label=_(u'_Add a Location…'),
icon_name=Icons.LIST_ADD)
act.connect('activate', self.open_location)
ag.add_action(act)
act = Action(name="BrowseLibrary",
label=_('Open _Browser'),
icon_name=Icons.EDIT_FIND)
ag.add_action(act)
act = Action(name="Preferences",
label=_('_Preferences'),
icon_name=Icons.PREFERENCES_SYSTEM)
act.connect('activate', self.__preferences)
ag.add_action(act)
act = Action(name="Plugins",
label=_('_Plugins'),
icon_name=Icons.SYSTEM_RUN)
act.connect('activate', self.__plugins)
ag.add_action(act)
act = Action(name="Quit",
label=_('_Quit'),
icon_name=Icons.APPLICATION_EXIT)
act.connect('activate', lambda *x: self.destroy())
ag.add_action_with_accel(act, "<Primary>Q")
act = Action(name="EditTags",
label=_('Edit _Tags'),
icon_name=Icons.DOCUMENT_PROPERTIES)
act.connect('activate', self.__current_song_prop)
ag.add_action(act)
act = Action(name="EditBookmarks", label=_(u"Edit Bookmarks…"))
connect_obj(act, 'activate', self.__edit_bookmarks, library.librarian,
player)
ag.add_action_with_accel(act, "<Primary>B")
act = Action(name="Previous",
label=_('Pre_vious'),
icon_name=Icons.MEDIA_SKIP_BACKWARD)
act.connect('activate', self.__previous_song)
ag.add_action_with_accel(act, "<Primary>comma")
act = Action(name="PlayPause",
label=_('_Play'),
icon_name=Icons.MEDIA_PLAYBACK_START)
act.connect('activate', self.__play_pause)
ag.add_action_with_accel(act, "<Primary>space")
act = Action(name="Next",
label=_('_Next'),
icon_name=Icons.MEDIA_SKIP_FORWARD)
act.connect('activate', self.__next_song)
ag.add_action_with_accel(act, "<Primary>period")
act = ToggleAction(name="StopAfter", label=_("Stop After This Song"))
ag.add_action_with_accel(act, "<shift>space")
# access point for the tray icon
self.stop_after = act
act = Action(name="Shortcuts", label=_("_Keyboard Shortcuts"))
act.connect('activate', self.__keyboard_shortcuts)
ag.add_action_with_accel(act, "<Primary>question")
act = Action(name="About",
label=_("_About"),
icon_name=Icons.HELP_ABOUT)
act.connect('activate', self.__show_about)
ag.add_action_with_accel(act, None)
act = Action(name="OnlineHelp",
label=_("Online Help"),
icon_name=Icons.HELP_BROWSER)
def website_handler(*args):
util.website(const.ONLINE_HELP)
act.connect('activate', website_handler)
ag.add_action_with_accel(act, "F1")
act = Action(name="SearchHelp", label=_("Search Help"))
def search_help_handler(*args):
util.website(const.SEARCH_HELP)
act.connect('activate', search_help_handler)
ag.add_action_with_accel(act, None)
act = Action(name="CheckUpdates",
label=_("_Check for Updates…"),
icon_name=Icons.NETWORK_SERVER)
def check_updates_handler(*args):
d = UpdateDialog(self)
d.run()
d.destroy()
act.connect('activate', check_updates_handler)
ag.add_action_with_accel(act, None)
act = Action(name="RefreshLibrary",
label=_("_Scan Library"),
icon_name=Icons.VIEW_REFRESH)
act.connect('activate', self.__rebuild, False)
ag.add_action(act)
current = config.get("memory", "browser")
try:
browsers.get(current)
except ValueError:
current = browsers.name(browsers.default)
first_action = None
for Kind in browsers.browsers:
name = browsers.name(Kind)
index = browsers.index(name)
action_name = "View" + Kind.__name__
act = RadioAction(name=action_name,
label=Kind.accelerated_name,
value=index)
act.join_group(first_action)
first_action = first_action or act
if name == current:
act.set_active(True)
ag.add_action_with_accel(act, "<Primary>%d" % ((index + 1) % 10, ))
assert first_action
self._browser_action = first_action
def action_callback(view_action, current_action):
current = browsers.name(
browsers.get(current_action.get_current_value()))
self._select_browser(view_action, current, library, player)
first_action.connect("changed", action_callback)
for Kind in browsers.browsers:
action = "Browser" + Kind.__name__
label = Kind.accelerated_name
name = browsers.name(Kind)
index = browsers.index(name)
act = Action(name=action, label=label)
def browser_activate(action, Kind):
LibraryBrowser.open(Kind, library, player)
act.connect('activate', browser_activate, Kind)
ag.add_action_with_accel(act,
"<Primary><alt>%d" % ((index + 1) % 10, ))
ui = Gtk.UIManager()
ui.insert_action_group(ag, -1)
menustr = MENU % {
"views": browser_menu_items(),
"browsers": secondary_browser_menu_items(),
"filters_menu": FilterMenu.MENU
}
ui.add_ui_from_string(menustr)
self._filter_menu = FilterMenu(library, player, ui)
# Cute. So. UIManager lets you attach tooltips, but when they're
# for menu items, they just get ignored. So here I get to actually
# attach them.
ui.get_widget("/Menu/File/RefreshLibrary").set_tooltip_text(
_("Check for changes in your library"))
return ui
def __show_about(self, *args):
about = AboutDialog(self, app)
about.run()
about.destroy()
def select_browser(self, browser_key, library, player):
"""Given a browser name (see browsers.get()) changes the current
browser.
Returns True if the passed browser ID is known and the change
was initiated.
"""
try:
Browser = browsers.get(browser_key)
except ValueError:
return False
action_name = "View%s" % Browser.__name__
for action in self._browser_action.get_group():
if action.get_name() == action_name:
action.set_active(True)
return True
return False
def _select_browser(self,
activator,
current,
library,
player,
restore=False):
Browser = browsers.get(current)
window = self.get_window()
if window:
window.set_cursor(Gdk.Cursor.new(Gdk.CursorType.WATCH))
# Wait for the cursor to update before continuing
while Gtk.events_pending():
Gtk.main_iteration()
config.set("memory", "browser", current)
if self.browser:
if not (self.browser.uses_main_library
and Browser.uses_main_library):
self.songlist.clear()
container = self.browser.__container
self.browser.unpack(container, self.songpane)
if self.browser.accelerators:
self.remove_accel_group(self.browser.accelerators)
container.destroy()
self.browser.destroy()
self.browser = Browser(library)
self.browser.connect('songs-selected', self.__browser_cb, library,
player)
self.browser.connect('songs-activated', self.__browser_activate)
if restore:
self.browser.restore()
self.browser.activate()
self.browser.finalize(restore)
if not restore:
self.browser.unfilter()
if self.browser.can_reorder:
self.songlist.enable_drop()
elif self.browser.dropped:
self.songlist.enable_drop(False)
else:
self.songlist.disable_drop()
if self.browser.accelerators:
self.add_accel_group(self.browser.accelerators)
container = self.browser.__container = self.browser.pack(self.songpane)
# Reset the cursor when done loading the browser
if window:
GLib.idle_add(window.set_cursor, None)
player.replaygain_profiles[1] = self.browser.replaygain_profiles
player.reset_replaygain()
self.__browserbox.add(container)
container.show()
self._filter_menu.set_browser(self.browser)
self.__hide_headers()
def __update_paused(self, player, paused):
menu = self.ui.get_widget("/Menu/Control/PlayPause")
image = menu.get_image()
if paused:
label, icon = _("_Play"), Icons.MEDIA_PLAYBACK_START
else:
label, icon = _("P_ause"), Icons.MEDIA_PLAYBACK_PAUSE
menu.set_label(label)
image.set_from_icon_name(icon, Gtk.IconSize.MENU)
def __song_ended(self, player, song, stopped):
# Check if the song should be removed, based on the
# active filter of the current browser.
active_filter = self.browser.active_filter
if song and active_filter and not active_filter(song):
iter_ = self.songlist.model.find(song)
if iter_:
self.songlist.remove_iters([iter_])
if self.stop_after.get_active():
player.paused = True
self.stop_after.set_active(False)
def __song_changed(self, library, songs, player):
if player.info in songs:
self.__update_title(player)
def __update_title(self, player):
song = player.info
title = "Quod Libet"
if song:
tag = config.gettext("settings", "window_title_pattern")
if tag:
title = song.comma(tag) + " - " + title
self.set_title(title)
def __song_started(self, player, song):
self.__update_title(player)
for wid in [
"Control/Next", "Control/StopAfter", "Song/EditTags",
"Song/Information", "Song/EditBookmarks", "Song/Jump"
]:
self.ui.get_widget('/Menu/' + wid).set_sensitive(bool(song))
# don't jump on stream changes (player.info != player.song)
main_should_jump = (song and player.song is song
and not self.songlist._activated
and config.getboolean("settings", "jump")
and self.songlist.sourced)
queue_should_jump = (song and player.song is song
and not self.qexpander.queue._activated
and config.getboolean("settings", "jump")
and self.qexpander.queue.sourced and
config.getboolean("memory", "queue_keep_songs"))
if main_should_jump:
self.__jump_to_current(False, self.songlist)
elif queue_should_jump:
self.__jump_to_current(False, self.qexpander.queue)
def __play_pause(self, *args):
app.player.playpause()
def __jump_to_current(self, explicit, songlist=None, force_scroll=False):
"""Select/scroll to the current playing song in the playlist.
If it can't be found tell the browser to properly fill the playlist
with an appropriate selection containing the song.
explicit means that the jump request comes from the user and not
from an event like song-started.
songlist is the songlist to be jumped within. Usually the main song
list or the queue. If None, the currently sourced songlist will be
used.
force_scroll will ask the browser to refill the playlist in any case.
"""
def idle_jump_to(song, select):
ok = songlist.jump_to_song(song, select=select)
if ok:
songlist.grab_focus()
return False
if not songlist:
if (config.getboolean("memory", "queue_keep_songs")
and self.qexpander.queue.sourced):
songlist = self.qexpander.queue
else:
songlist = self.songlist
if app.player is None:
return
song = app.player.song
# We are not playing a song
if song is None:
return
if not force_scroll:
ok = songlist.jump_to_song(song, select=explicit)
else:
assert explicit
ok = False
if ok:
songlist.grab_focus()
elif explicit:
# if we can't find it and the user requested it, try harder
self.browser.scroll(song)
# We need to wait until the browser has finished
# scrolling/filling and the songlist is ready.
# Not perfect, but works for now.
GLib.idle_add(idle_jump_to,
song,
explicit,
priority=GLib.PRIORITY_LOW)
def __next_song(self, *args):
app.player.next()
def __previous_song(self, *args):
app.player.previous()
def __rebuild(self, activator, force):
scan_library(self.__library, force)
# Set up the preferences window.
def __preferences(self, activator):
window = PreferencesWindow(self)
window.show()
def __plugins(self, activator):
window = PluginWindow(self)
window.show()
def open_location(self, action):
name = GetStringDialog(self,
_("Add a Location"),
_("Enter the location of an audio file:"),
button_label=_("_Add"),
button_icon=Icons.LIST_ADD).run()
if name:
if not uri_is_valid(name):
ErrorMessage(
self, _("Unable to add location"),
_("%s is not a valid location.") %
(util.bold(util.escape(name)))).run()
elif not app.player.can_play_uri(name):
ErrorMessage(
self, _("Unable to add location"),
_("%s uses an unsupported protocol.") %
(util.bold(util.escape(name)))).run()
else:
if name not in self.__library:
self.__library.add([RemoteFile(name)])
def open_chooser(self, action):
if action.get_name() == "AddFolders":
fns = choose_folders(self, _("Add Music"), _("_Add Folders"))
if fns:
# scan them
copool.add(self.__library.scan,
fns,
cofuncid="library",
funcid="library")
else:
patterns = ["*" + path2fsn(k) for k in formats.loaders.keys()]
choose_filter = create_chooser_filter(_("Music Files"), patterns)
fns = choose_files(self, _("Add Music"), _("_Add Files"),
choose_filter)
if fns:
for filename in fns:
self.__library.add_filename(filename)
def __songs_popup_menu(self, songlist):
path, col = songlist.get_cursor()
header = col.header_name
menu = self.songlist.Menu(header, self.browser, self.__library)
if menu is not None:
return self.songlist.popup_menu(menu, 0,
Gtk.get_current_event_time())
def __current_song_prop(self, *args):
song = app.player.song
if song:
librarian = self.__library.librarian
window = SongProperties(librarian, [song], parent=self)
window.show()
def __current_song_info(self, *args):
song = app.player.song
if song:
librarian = self.__library.librarian
window = Information(librarian, [song], self)
window.show()
def __browser_activate(self, browser):
app.player._reset()
def __browser_cb(self, browser, songs, sorted, library, player):
if browser.background:
bg = background_filter()
if bg:
songs = list(filter(bg, songs))
self.songlist.set_songs(songs, sorted)
# After the first time the browser activates, which should always
# happen if we start up and restore, restore the playing song.
# Because the browser has send us songs we can be sure it has
# registered all its libraries.
if self.__first_browser_set:
self.__first_browser_set = False
song = library.librarian.get(config.get("memory", "song"))
seek_pos = config.getfloat("memory", "seek", 0)
config.set("memory", "seek", 0)
if song is not None:
player.setup(self.playlist, song, seek_pos)
if self.__restore_cb:
self.__restore_cb()
self.__restore_cb = None
def __hide_headers(self, activator=None):
for column in self.songlist.get_columns():
if self.browser.headers is None:
column.set_visible(True)
else:
for tag in util.tagsplit(column.header_name):
if tag in self.browser.headers:
column.set_visible(True)
break
else:
column.set_visible(False)
def __cols_changed(self, songlist):
headers = [col.header_name for col in songlist.get_columns()]
try:
headers.remove('~current')
except ValueError:
pass
if len(headers) == len(get_columns()):
# Not an addition or removal (handled separately)
set_columns(headers)
SongList.headers = headers
def __make_query(self, query):
if self.browser.can_filter_text():
self.browser.filter_text(query.encode('utf-8'))
self.browser.activate()
def __set_totals(self, info, songs):
length = sum(song.get("~#length", 0) for song in songs)
t = self.browser.status_text(count=len(songs),
time=util.format_time_preferred(length))
self.statusbar.set_default_text(t)
def test_random_at_startup(self):
self.failIf(isinstance(self.queue.model.order, OrderShuffle))
quodlibet.config.set("memory", "shufflequeue", True)
self.queue = self.queue = QueueExpander(SongLibrary(), NullPlayer())
# See issue #2411
self.failUnless(isinstance(self.queue.model.order, OrderShuffle))
def setUp(self):
quodlibet.config.init()
player = NullPlayer()
self.queue = QueueExpander(SongLibrary(), player)
def setUp(self):
quodlibet.config.init()
player = NullPlayer()
self.queue = QueueExpander(SongLibrary(), player)
def __init__(self, library, player, headless=False, restore_cb=None):
super().__init__(dialog=False)
self.__destroyed = False
self.__update_title(player)
self.set_default_size(600, 480)
main_box = Gtk.VBox()
self.add(main_box)
self.side_book = qltk.Notebook()
# get the playlist up before other stuff
self.songlist = MainSongList(library, player)
self.songlist.connect("key-press-event", self.__songlist_key_press)
self.songlist.connect_after('drag-data-received',
self.__songlist_drag_data_recv)
self.song_scroller = ScrolledWindow()
self.song_scroller.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
self.song_scroller.set_shadow_type(Gtk.ShadowType.IN)
self.song_scroller.add(self.songlist)
self.qexpander = QueueExpander(library, player)
self.qexpander.set_no_show_all(True)
self.qexpander.set_visible(config.getboolean("memory", "queue"))
def on_queue_visible(qex, param):
config.set("memory", "queue", str(qex.get_visible()))
self.qexpander.connect("notify::visible", on_queue_visible)
self.playlist = PlaylistMux(player, self.qexpander.model,
self.songlist.model)
self.__player = player
# create main menubar, load/restore accelerator groups
self.__library = library
ui = self.__create_menu(player, library)
accel_group = ui.get_accel_group()
self.add_accel_group(accel_group)
def scroll_and_jump(*args):
self.__jump_to_current(True, None, True)
keyval, mod = Gtk.accelerator_parse("<Primary><shift>J")
accel_group.connect(keyval, mod, 0, scroll_and_jump)
# custom accel map
accel_fn = os.path.join(quodlibet.get_user_dir(), "accels")
Gtk.AccelMap.load(accel_fn)
# save right away so we fill the file with example comments of all
# accels
Gtk.AccelMap.save(accel_fn)
menubar = ui.get_widget("/Menu")
# Since https://git.gnome.org/browse/gtk+/commit/?id=b44df22895c79
# toplevel menu items show an empty 16x16 image. While we don't
# need image items there UIManager creates them by default.
# Work around by removing the empty GtkImages
for child in menubar.get_children():
if isinstance(child, Gtk.ImageMenuItem):
child.set_image(None)
main_box.pack_start(menubar, False, True, 0)
top_bar = TopBar(self, player, library)
main_box.pack_start(top_bar, False, True, 0)
self.top_bar = top_bar
self.__browserbox = Align(bottom=3)
self.__paned = paned = ConfigRHPaned("memory", "sidebar_pos", 0.25)
paned.pack1(self.__browserbox, resize=True)
# We'll pack2 when necessary (when the first sidebar plugin is set up)
main_box.pack_start(paned, True, True, 0)
play_order = PlayOrderWidget(self.songlist.model, player)
statusbox = StatusBarBox(play_order, self.qexpander)
self.order = play_order
self.statusbar = statusbox.statusbar
main_box.pack_start(Align(statusbox, border=3, top=-3), False, True, 0)
self.songpane = SongListPaned(self.song_scroller, self.qexpander)
self.songpane.show_all()
try:
orders = []
for e in config.getstringlist('memory', 'sortby', []):
orders.append((e[1:], int(e[0])))
except ValueError:
pass
else:
self.songlist.set_sort_orders(orders)
self.browser = None
self.ui = ui
main_box.show_all()
self._playback_error_dialog = None
connect_destroy(player, 'song-started', self.__song_started)
connect_destroy(player, 'paused', self.__update_paused, True)
connect_destroy(player, 'unpaused', self.__update_paused, False)
# make sure we redraw all error indicators before opening
# a dialog (blocking the main loop), so connect after default handlers
connect_after_destroy(player, 'error', self.__player_error)
# connect after to let SongTracker update stats
connect_after_destroy(player, "song-ended", self.__song_ended)
# set at least the playlist. the song should be restored
# after the browser emits the song list
player.setup(self.playlist, None, 0)
self.__restore_cb = restore_cb
self.__first_browser_set = True
restore_browser = not headless
try:
self._select_browser(self, config.get("memory", "browser"),
library, player, restore_browser)
except:
config.set("memory", "browser", browsers.name(browsers.default))
config.save()
raise
self.songlist.connect('popup-menu', self.__songs_popup_menu)
self.songlist.connect('columns-changed', self.__cols_changed)
self.songlist.connect('columns-changed', self.__hide_headers)
self.songlist.info.connect("changed", self.__set_totals)
lib = library.librarian
connect_destroy(lib, 'changed', self.__song_changed, player)
targets = [("text/uri-list", Gtk.TargetFlags.OTHER_APP, DND_URI_LIST)]
targets = [Gtk.TargetEntry.new(*t) for t in targets]
self.drag_dest_set(Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY)
self.connect('drag-data-received', self.__drag_data_received)
if not headless:
on_first_map(self, self.__configure_scan_dirs, library)
if config.getboolean('library', 'refresh_on_start'):
self.__rebuild(None, False)
self.connect("key-press-event", self.__key_pressed, player)
self.connect("destroy", self.__destroy)
self.enable_window_tracking("quodlibet")
def setUp(self):
quodlibet.config.init()
player = NullPlayer()
self.queue = QueueExpander(Gtk.CheckMenuItem(), SongLibrary(), player)
def __init__(self, library, player, headless=False, restore_cb=None):
super(QuodLibetWindow, self).__init__(dialog=False)
self.last_dir = get_home_dir()
self.__destroyed = False
self.__update_title(player)
self.set_default_size(550, 450)
main_box = Gtk.VBox()
self.add(main_box)
# create main menubar, load/restore accelerator groups
self.__library = library
ui = self.__create_menu(player, library)
accel_group = ui.get_accel_group()
self.add_accel_group(accel_group)
def scroll_and_jump(*args):
self.__jump_to_current(True, True)
keyval, mod = Gtk.accelerator_parse("<control><shift>J")
accel_group.connect(keyval, mod, 0, scroll_and_jump)
# dbus app menu
# Unity puts the app menu next to our menu bar. Since it only contains
# menu items also available in the menu bar itself, don't add it.
if not util.is_unity():
AppMenu(self, ui.get_action_groups()[0])
# custom accel map
accel_fn = os.path.join(quodlibet.get_user_dir(), "accels")
Gtk.AccelMap.load(accel_fn)
# save right away so we fill the file with example comments of all
# accels
Gtk.AccelMap.save(accel_fn)
menubar = ui.get_widget("/Menu")
# Since https://git.gnome.org/browse/gtk+/commit/?id=b44df22895c79
# toplevel menu items show an empty 16x16 image. While we don't
# need image items there UIManager creates them by default.
# Work around by removing the empty GtkImages
for child in menubar.get_children():
if isinstance(child, Gtk.ImageMenuItem):
child.set_image(None)
main_box.pack_start(menubar, False, True, 0)
# get the playlist up before other stuff
self.songlist = MainSongList(library, player)
self.songlist.show_all()
self.songlist.connect("key-press-event", self.__songlist_key_press)
self.songlist.connect_after('drag-data-received',
self.__songlist_drag_data_recv)
self.song_scroller = SongListScroller(
ui.get_widget("/Menu/View/SongList"))
self.song_scroller.add(self.songlist)
self.qexpander = QueueExpander(ui.get_widget("/Menu/View/Queue"),
library, player)
self.playlist = PlaylistMux(player, self.qexpander.model,
self.songlist.model)
top_bar = TopBar(self, player, library)
main_box.pack_start(top_bar, False, True, 0)
self.top_bar = top_bar
self.__browserbox = Align(bottom=3)
main_box.pack_start(self.__browserbox, True, True, 0)
statusbox = StatusBarBox(self.songlist.model, player)
self.order = statusbox.order
self.repeat = statusbox.repeat
self.statusbar = statusbox.statusbar
main_box.pack_start(Align(statusbox, border=3, top=-3, right=3), False,
True, 0)
self.songpane = ConfigRVPaned("memory", "queue_position", 0.75)
self.songpane.pack1(self.song_scroller, resize=True, shrink=False)
self.songpane.pack2(self.qexpander, resize=True, shrink=False)
self.__handle_position = self.songpane.get_property("position")
def songpane_button_press_cb(pane, event):
"""If we start to drag the pane handle while the
queue expander is unexpanded, expand it and move the handle
to the bottom, so we can 'drag' the queue out
"""
if event.window != pane.get_handle_window():
return False
if not self.qexpander.get_expanded():
self.qexpander.set_expanded(True)
pane.set_relative(1.0)
return False
self.songpane.connect("button-press-event", songpane_button_press_cb)
self.song_scroller.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::visible', self.__show_or)
self.qexpander.connect('notify::expanded', self.__expand_or)
self.qexpander.connect('draw', self.__qex_size_allocate)
self.songpane.connect('notify', self.__moved_pane_handle)
try:
orders = []
for e in config.getstringlist('memory', 'sortby', []):
orders.append((e[1:], int(e[0])))
except ValueError:
pass
else:
self.songlist.set_sort_orders(orders)
self.browser = None
self.ui = ui
main_box.show_all()
self._playback_error_dialog = None
connect_destroy(player, 'song-started', self.__song_started)
connect_destroy(player, 'paused', self.__update_paused, True)
connect_destroy(player, 'unpaused', self.__update_paused, False)
# make sure we redraw all error indicators before opening
# a dialog (blocking the main loop), so connect after default handlers
connect_after_destroy(player, 'error', self.__player_error)
# connect after to let SongTracker update stats
connect_after_destroy(player, "song-ended", self.__song_ended)
# set at least the playlist. the song should be restored
# after the browser emits the song list
player.setup(self.playlist, None, 0)
self.__restore_cb = restore_cb
self.__first_browser_set = True
restore_browser = not headless
try:
self.select_browser(self, config.get("memory", "browser"), library,
player, restore_browser)
except:
config.set("memory", "browser", browsers.name(0))
config.save()
raise
self.showhide_playlist(ui.get_widget("/Menu/View/SongList"))
self.showhide_playqueue(ui.get_widget("/Menu/View/Queue"))
self.songlist.connect('popup-menu', self.__songs_popup_menu)
self.songlist.connect('columns-changed', self.__cols_changed)
self.songlist.connect('columns-changed', self.__hide_headers)
self.songlist.info.connect("changed", self.__set_time)
lib = library.librarian
connect_destroy(lib, 'changed', self.__song_changed, player)
targets = [("text/uri-list", Gtk.TargetFlags.OTHER_APP, DND_URI_LIST)]
targets = [Gtk.TargetEntry.new(*t) for t in targets]
self.drag_dest_set(Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY)
self.connect('drag-data-received', self.__drag_data_received)
if not headless:
on_first_map(self, self.__configure_scan_dirs, library)
if config.getboolean('library', 'refresh_on_start'):
self.__rebuild(None, False)
self.connect("key-press-event", self.__key_pressed, player)
self.connect("destroy", self.__destroy)
self.enable_window_tracking("quodlibet")
class QuodLibetWindow(Window, PersistentWindowMixin, AppWindow):
def __init__(self, library, player, headless=False, restore_cb=None):
super(QuodLibetWindow, self).__init__(dialog=False)
self.__destroyed = False
self.__update_title(player)
self.set_default_size(600, 480)
main_box = Gtk.VBox()
self.add(main_box)
self.side_book = qltk.Notebook()
# get the playlist up before other stuff
self.songlist = MainSongList(library, player)
self.songlist.connect("key-press-event", self.__songlist_key_press)
self.songlist.connect_after(
'drag-data-received', self.__songlist_drag_data_recv)
self.song_scroller = ScrolledWindow()
self.song_scroller.set_policy(
Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
self.song_scroller.set_shadow_type(Gtk.ShadowType.IN)
self.song_scroller.add(self.songlist)
self.qexpander = QueueExpander(library, player)
self.qexpander.set_no_show_all(True)
self.qexpander.set_visible(config.getboolean("memory", "queue"))
def on_queue_visible(qex, param):
config.set("memory", "queue", str(qex.get_visible()))
self.qexpander.connect("notify::visible", on_queue_visible)
self.playlist = PlaylistMux(
player, self.qexpander.model, self.songlist.model)
self.__player = player
# create main menubar, load/restore accelerator groups
self.__library = library
ui = self.__create_menu(player, library)
accel_group = ui.get_accel_group()
self.add_accel_group(accel_group)
def scroll_and_jump(*args):
self.__jump_to_current(True, None, True)
keyval, mod = Gtk.accelerator_parse("<Primary><shift>J")
accel_group.connect(keyval, mod, 0, scroll_and_jump)
# custom accel map
accel_fn = os.path.join(quodlibet.get_user_dir(), "accels")
Gtk.AccelMap.load(accel_fn)
# save right away so we fill the file with example comments of all
# accels
Gtk.AccelMap.save(accel_fn)
menubar = ui.get_widget("/Menu")
# Since https://git.gnome.org/browse/gtk+/commit/?id=b44df22895c79
# toplevel menu items show an empty 16x16 image. While we don't
# need image items there UIManager creates them by default.
# Work around by removing the empty GtkImages
for child in menubar.get_children():
if isinstance(child, Gtk.ImageMenuItem):
child.set_image(None)
main_box.pack_start(menubar, False, True, 0)
top_bar = TopBar(self, player, library)
main_box.pack_start(top_bar, False, True, 0)
self.top_bar = top_bar
self.__browserbox = Align(bottom=3)
self.__paned = paned = ConfigRHPaned("memory", "sidebar_pos", 0.25)
paned.pack1(self.__browserbox, resize=True)
# We'll pack2 when necessary (when the first sidebar plugin is set up)
main_box.pack_start(paned, True, True, 0)
play_order = PlayOrderWidget(self.songlist.model, player)
statusbox = StatusBarBox(play_order, self.qexpander)
self.order = play_order
self.statusbar = statusbox.statusbar
main_box.pack_start(
Align(statusbox, border=3, top=-3),
False, True, 0)
self.songpane = SongListPaned(self.song_scroller, self.qexpander)
self.songpane.show_all()
try:
orders = []
for e in config.getstringlist('memory', 'sortby', []):
orders.append((e[1:], int(e[0])))
except ValueError:
pass
else:
self.songlist.set_sort_orders(orders)
self.browser = None
self.ui = ui
main_box.show_all()
self._playback_error_dialog = None
connect_destroy(player, 'song-started', self.__song_started)
connect_destroy(player, 'paused', self.__update_paused, True)
connect_destroy(player, 'unpaused', self.__update_paused, False)
# make sure we redraw all error indicators before opening
# a dialog (blocking the main loop), so connect after default handlers
connect_after_destroy(player, 'error', self.__player_error)
# connect after to let SongTracker update stats
connect_after_destroy(player, "song-ended", self.__song_ended)
# set at least the playlist. the song should be restored
# after the browser emits the song list
player.setup(self.playlist, None, 0)
self.__restore_cb = restore_cb
self.__first_browser_set = True
restore_browser = not headless
try:
self._select_browser(
self, config.get("memory", "browser"), library, player,
restore_browser)
except:
config.set("memory", "browser", browsers.name(browsers.default))
config.save()
raise
self.songlist.connect('popup-menu', self.__songs_popup_menu)
self.songlist.connect('columns-changed', self.__cols_changed)
self.songlist.connect('columns-changed', self.__hide_headers)
self.songlist.info.connect("changed", self.__set_totals)
lib = library.librarian
connect_destroy(lib, 'changed', self.__song_changed, player)
targets = [("text/uri-list", Gtk.TargetFlags.OTHER_APP, DND_URI_LIST)]
targets = [Gtk.TargetEntry.new(*t) for t in targets]
self.drag_dest_set(
Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY)
self.connect('drag-data-received', self.__drag_data_received)
if not headless:
on_first_map(self, self.__configure_scan_dirs, library)
if config.getboolean('library', 'refresh_on_start'):
self.__rebuild(None, False)
self.connect("key-press-event", self.__key_pressed, player)
self.connect("destroy", self.__destroy)
self.enable_window_tracking("quodlibet")
def hide_side_book(self):
self.side_book.hide()
def add_sidebar(self, box, name):
vbox = Gtk.Box(margin=0)
vbox.pack_start(box, True, True, 0)
vbox.show()
if self.side_book_empty:
self.add_sidebar_to_layout(self.side_book)
self.side_book.append_page(vbox, label=name)
self.side_book.set_tab_detachable(vbox, False)
self.side_book.show_all()
return vbox
def remove_sidebar(self, widget):
self.side_book.remove_page(self.side_book.page_num(widget))
if self.side_book_empty:
print_d("Hiding sidebar")
self.__paned.remove(self.__paned.get_children()[1])
def add_sidebar_to_layout(self, widget):
print_d("Recreating sidebar")
align = Align(widget, top=6, bottom=3)
self.__paned.pack2(align, shrink=True)
align.show_all()
@property
def side_book_empty(self):
return not self.side_book.get_children()
def set_seekbar_widget(self, widget):
"""Add an alternative seek bar widget.
Args:
widget (Gtk.Widget): a new widget or None to remove the current one
"""
self.top_bar.set_seekbar_widget(widget)
def set_as_osx_window(self, osx_app):
assert osx_app
self._dock_menu = DockMenu(app)
osx_app.set_dock_menu(self._dock_menu)
menu = self.ui.get_widget("/Menu")
menu.hide()
osx_app.set_menu_bar(menu)
# Reparent some items to the "Application" menu
item = self.ui.get_widget('/Menu/Help/About')
osx_app.insert_app_menu_item(item, 0)
osx_app.insert_app_menu_item(Gtk.SeparatorMenuItem(), 1)
item = self.ui.get_widget('/Menu/File/Preferences')
osx_app.insert_app_menu_item(item, 2)
quit_item = self.ui.get_widget('/Menu/File/Quit')
quit_item.hide()
def get_is_persistent(self):
return True
def open_file(self, filename):
assert isinstance(filename, fsnative)
song = self.__library.add_filename(filename, add=False)
if song is not None:
if self.__player.go_to(song):
self.__player.paused = False
return True
else:
return False
def __player_error(self, player, song, player_error):
# it's modal, but mmkeys etc. can still trigger new ones
if self._playback_error_dialog:
self._playback_error_dialog.destroy()
dialog = PlaybackErrorDialog(self, player_error)
self._playback_error_dialog = dialog
dialog.run()
self._playback_error_dialog = None
def __configure_scan_dirs(self, library):
"""Get user to configure scan dirs, if none is set up"""
if not get_scan_dirs() and not len(library) and \
quodlibet.is_first_session("quodlibet"):
print_d("Couldn't find any scan dirs")
resp = ConfirmLibDirSetup(self).run()
if resp == ConfirmLibDirSetup.RESPONSE_SETUP:
prefs = PreferencesWindow(self)
prefs.set_page("library")
prefs.show()
def __keyboard_shortcuts(self, action):
show_shortcuts(self)
def __edit_bookmarks(self, librarian, player):
if player.song:
window = EditBookmarks(self, librarian, player)
window.show()
def __key_pressed(self, widget, event, player):
if not player.song:
return
def seek_relative(seconds):
current = player.get_position()
current += seconds * 1000
current = min(player.song("~#length") * 1000 - 1, current)
current = max(0, current)
player.seek(current)
if qltk.is_accel(event, "<alt>Right"):
seek_relative(10)
return True
elif qltk.is_accel(event, "<alt>Left"):
seek_relative(-10)
return True
def __destroy(self, *args):
self.playlist.destroy()
# The tray icon plugin tries to unhide QL because it gets disabled
# on Ql exit. The window should stay hidden after destroy.
self.show = lambda: None
self.present = self.show
def __drag_data_received(self, widget, ctx, x, y, sel, tid, etime):
assert tid == DND_URI_LIST
uris = sel.get_uris()
dirs = []
error = False
for uri in uris:
try:
filename = uri2fsn(uri)
except ValueError:
filename = None
if filename is not None:
loc = os.path.normpath(filename)
if os.path.isdir(loc):
dirs.append(loc)
else:
loc = os.path.realpath(loc)
if loc not in self.__library:
self.__library.add_filename(loc)
elif app.player.can_play_uri(uri):
if uri not in self.__library:
self.__library.add([RemoteFile(uri)])
else:
error = True
break
Gtk.drag_finish(ctx, not error, False, etime)
if error:
ErrorMessage(
self, _("Unable to add songs"),
_("%s uses an unsupported protocol.") % util.bold(uri)).run()
else:
if dirs:
copool.add(
self.__library.scan, dirs,
cofuncid="library", funcid="library")
def __songlist_key_press(self, songlist, event):
return self.browser.key_pressed(event)
def __songlist_drag_data_recv(self, view, *args):
if self.browser.can_reorder:
songs = view.get_songs()
self.browser.reordered(songs)
self.songlist.clear_sort()
def __create_menu(self, player, library):
def add_view_items(ag):
act = Action(name="Information", label=_('_Information'),
icon_name=Icons.DIALOG_INFORMATION)
act.connect('activate', self.__current_song_info)
ag.add_action(act)
act = Action(name="Jump", label=_('_Jump to Playing Song'),
icon_name=Icons.GO_JUMP)
self.__jump_to_current(True, None, True)
act.connect('activate', self.__jump_to_current)
ag.add_action_with_accel(act, "<Primary>J")
def add_top_level_items(ag):
ag.add_action(Action(name="File", label=_("_File")))
ag.add_action(Action(name="Song", label=_("_Song")))
ag.add_action(Action(name="View", label=_('_View')))
ag.add_action(Action(name="Browse", label=_("_Browse")))
ag.add_action(Action(name="Control", label=_('_Control')))
ag.add_action(Action(name="Help", label=_('_Help')))
ag = Gtk.ActionGroup.new('QuodLibetWindowActions')
add_top_level_items(ag)
add_view_items(ag)
act = Action(name="AddFolders", label=_(u'_Add a Folder…'),
icon_name=Icons.LIST_ADD)
act.connect('activate', self.open_chooser)
ag.add_action_with_accel(act, "<Primary>O")
act = Action(name="AddFiles", label=_(u'_Add a File…'),
icon_name=Icons.LIST_ADD)
act.connect('activate', self.open_chooser)
ag.add_action(act)
act = Action(name="AddLocation", label=_(u'_Add a Location…'),
icon_name=Icons.LIST_ADD)
act.connect('activate', self.open_location)
ag.add_action(act)
act = Action(name="BrowseLibrary", label=_('Open _Browser'),
icon_name=Icons.EDIT_FIND)
ag.add_action(act)
act = Action(name="Preferences", label=_('_Preferences'),
icon_name=Icons.PREFERENCES_SYSTEM)
act.connect('activate', self.__preferences)
ag.add_action(act)
act = Action(name="Plugins", label=_('_Plugins'),
icon_name=Icons.SYSTEM_RUN)
act.connect('activate', self.__plugins)
ag.add_action(act)
act = Action(name="Quit", label=_('_Quit'),
icon_name=Icons.APPLICATION_EXIT)
act.connect('activate', lambda *x: self.destroy())
ag.add_action_with_accel(act, "<Primary>Q")
act = Action(name="EditTags", label=_('Edit _Tags'),
icon_name=Icons.DOCUMENT_PROPERTIES)
act.connect('activate', self.__current_song_prop)
ag.add_action(act)
act = Action(name="EditBookmarks", label=_(u"Edit Bookmarks…"))
connect_obj(act, 'activate', self.__edit_bookmarks,
library.librarian, player)
ag.add_action_with_accel(act, "<Primary>B")
act = Action(name="Previous", label=_('Pre_vious'),
icon_name=Icons.MEDIA_SKIP_BACKWARD)
act.connect('activate', self.__previous_song)
ag.add_action_with_accel(act, "<Primary>comma")
act = Action(name="PlayPause", label=_('_Play'),
icon_name=Icons.MEDIA_PLAYBACK_START)
act.connect('activate', self.__play_pause)
ag.add_action_with_accel(act, "<Primary>space")
act = Action(name="Next", label=_('_Next'),
icon_name=Icons.MEDIA_SKIP_FORWARD)
act.connect('activate', self.__next_song)
ag.add_action_with_accel(act, "<Primary>period")
act = ToggleAction(name="StopAfter", label=_("Stop After This Song"))
ag.add_action_with_accel(act, "<shift>space")
# access point for the tray icon
self.stop_after = act
act = Action(name="Shortcuts", label=_("_Keyboard Shortcuts"))
act.connect('activate', self.__keyboard_shortcuts)
ag.add_action_with_accel(act, "<Primary>question")
act = Action(name="About", label=_("_About"),
icon_name=Icons.HELP_ABOUT)
act.connect('activate', self.__show_about)
ag.add_action_with_accel(act, None)
act = Action(name="OnlineHelp", label=_("Online Help"),
icon_name=Icons.HELP_BROWSER)
def website_handler(*args):
util.website(const.ONLINE_HELP)
act.connect('activate', website_handler)
ag.add_action_with_accel(act, "F1")
act = Action(name="SearchHelp", label=_("Search Help"))
def search_help_handler(*args):
util.website(const.SEARCH_HELP)
act.connect('activate', search_help_handler)
ag.add_action_with_accel(act, None)
act = Action(name="CheckUpdates", label=_("_Check for Updates…"),
icon_name=Icons.NETWORK_SERVER)
def check_updates_handler(*args):
d = UpdateDialog(self)
d.run()
d.destroy()
act.connect('activate', check_updates_handler)
ag.add_action_with_accel(act, None)
act = Action(
name="RefreshLibrary", label=_("_Scan Library"),
icon_name=Icons.VIEW_REFRESH)
act.connect('activate', self.__rebuild, False)
ag.add_action(act)
current = config.get("memory", "browser")
try:
browsers.get(current)
except ValueError:
current = browsers.name(browsers.default)
first_action = None
for Kind in browsers.browsers:
name = browsers.name(Kind)
index = browsers.index(name)
action_name = "View" + Kind.__name__
act = RadioAction(name=action_name, label=Kind.accelerated_name,
value=index)
act.join_group(first_action)
first_action = first_action or act
if name == current:
act.set_active(True)
ag.add_action_with_accel(act, "<Primary>%d" % ((index + 1) % 10,))
assert first_action
self._browser_action = first_action
def action_callback(view_action, current_action):
current = browsers.name(
browsers.get(current_action.get_current_value()))
self._select_browser(view_action, current, library, player)
first_action.connect("changed", action_callback)
for Kind in browsers.browsers:
action = "Browser" + Kind.__name__
label = Kind.accelerated_name
name = browsers.name(Kind)
index = browsers.index(name)
act = Action(name=action, label=label)
def browser_activate(action, Kind):
LibraryBrowser.open(Kind, library, player)
act.connect('activate', browser_activate, Kind)
ag.add_action_with_accel(act,
"<Primary><alt>%d" % ((index + 1) % 10,))
ui = Gtk.UIManager()
ui.insert_action_group(ag, -1)
menustr = MENU % {
"views": browser_menu_items(),
"browsers": secondary_browser_menu_items(),
"filters_menu": FilterMenu.MENU
}
ui.add_ui_from_string(menustr)
self._filter_menu = FilterMenu(library, player, ui)
# Cute. So. UIManager lets you attach tooltips, but when they're
# for menu items, they just get ignored. So here I get to actually
# attach them.
ui.get_widget("/Menu/File/RefreshLibrary").set_tooltip_text(
_("Check for changes in your library"))
return ui
def __show_about(self, *args):
about = AboutDialog(self, app)
about.run()
about.destroy()
def select_browser(self, browser_key, library, player):
"""Given a browser name (see browsers.get()) changes the current
browser.
Returns True if the passed browser ID is known and the change
was initiated.
"""
try:
Browser = browsers.get(browser_key)
except ValueError:
return False
action_name = "View%s" % Browser.__name__
for action in self._browser_action.get_group():
if action.get_name() == action_name:
action.set_active(True)
return True
return False
def _select_browser(self, activator, current, library, player,
restore=False):
Browser = browsers.get(current)
window = self.get_window()
if window:
window.set_cursor(Gdk.Cursor.new(Gdk.CursorType.WATCH))
# Wait for the cursor to update before continuing
while Gtk.events_pending():
Gtk.main_iteration()
config.set("memory", "browser", current)
if self.browser:
if not (self.browser.uses_main_library and
Browser.uses_main_library):
self.songlist.clear()
container = self.browser.__container
self.browser.unpack(container, self.songpane)
if self.browser.accelerators:
self.remove_accel_group(self.browser.accelerators)
container.destroy()
self.browser.destroy()
self.browser = Browser(library)
self.browser.connect('songs-selected',
self.__browser_cb, library, player)
self.browser.connect('songs-activated', self.__browser_activate)
if restore:
self.browser.restore()
self.browser.activate()
self.browser.finalize(restore)
if self.browser.can_reorder:
self.songlist.enable_drop()
elif self.browser.dropped:
self.songlist.enable_drop(False)
else:
self.songlist.disable_drop()
if self.browser.accelerators:
self.add_accel_group(self.browser.accelerators)
container = self.browser.__container = self.browser.pack(self.songpane)
# Reset the cursor when done loading the browser
if window:
GLib.idle_add(window.set_cursor, None)
player.replaygain_profiles[1] = self.browser.replaygain_profiles
player.reset_replaygain()
self.__browserbox.add(container)
container.show()
self._filter_menu.set_browser(self.browser)
self.__hide_headers()
def __update_paused(self, player, paused):
menu = self.ui.get_widget("/Menu/Control/PlayPause")
image = menu.get_image()
if paused:
label, icon = _("_Play"), Icons.MEDIA_PLAYBACK_START
else:
label, icon = _("P_ause"), Icons.MEDIA_PLAYBACK_PAUSE
menu.set_label(label)
image.set_from_icon_name(icon, Gtk.IconSize.MENU)
def __song_ended(self, player, song, stopped):
# Check if the song should be removed, based on the
# active filter of the current browser.
active_filter = self.browser.active_filter
if song and active_filter and not active_filter(song):
iter_ = self.songlist.model.find(song)
if iter_:
self.songlist.remove_iters([iter_])
if self.stop_after.get_active():
player.paused = True
self.stop_after.set_active(False)
def __song_changed(self, library, songs, player):
if player.info in songs:
self.__update_title(player)
def __update_title(self, player):
song = player.info
title = "Quod Libet"
if song:
tag = config.gettext("settings", "window_title_pattern")
if tag:
title = song.comma(tag) + " - " + title
self.set_title(title)
def __song_started(self, player, song):
self.__update_title(player)
for wid in ["Control/Next", "Control/StopAfter",
"Song/EditTags", "Song/Information",
"Song/EditBookmarks", "Song/Jump"]:
self.ui.get_widget('/Menu/' + wid).set_sensitive(bool(song))
# don't jump on stream changes (player.info != player.song)
main_should_jump = (song and player.song is song and
not self.songlist._activated and
config.getboolean("settings", "jump") and
self.songlist.sourced)
queue_should_jump = (song and player.song is song and
not self.qexpander.queue._activated and
config.getboolean("settings", "jump") and
self.qexpander.queue.sourced and
config.getboolean("memory", "queue_keep_songs"))
if main_should_jump:
self.__jump_to_current(False, self.songlist)
elif queue_should_jump:
self.__jump_to_current(False, self.qexpander.queue)
def __play_pause(self, *args):
app.player.playpause()
def __jump_to_current(self, explicit, songlist=None, force_scroll=False):
"""Select/scroll to the current playing song in the playlist.
If it can't be found tell the browser to properly fill the playlist
with an appropriate selection containing the song.
explicit means that the jump request comes from the user and not
from an event like song-started.
songlist is the songlist to be jumped within. Usually the main song
list or the queue. If None, the currently sourced songlist will be
used.
force_scroll will ask the browser to refill the playlist in any case.
"""
def idle_jump_to(song, select):
ok = songlist.jump_to_song(song, select=select)
if ok:
songlist.grab_focus()
return False
if not songlist:
if (config.getboolean("memory", "queue_keep_songs")
and self.qexpander.queue.sourced):
songlist = self.qexpander.queue
else:
songlist = self.songlist
if app.player is None:
return
song = app.player.song
# We are not playing a song
if song is None:
return
if not force_scroll:
ok = songlist.jump_to_song(song, select=explicit)
else:
assert explicit
ok = False
if ok:
songlist.grab_focus()
elif explicit:
# if we can't find it and the user requested it, try harder
self.browser.scroll(song)
# We need to wait until the browser has finished
# scrolling/filling and the songlist is ready.
# Not perfect, but works for now.
GLib.idle_add(
idle_jump_to, song, explicit, priority=GLib.PRIORITY_LOW)
def __next_song(self, *args):
app.player.next()
def __previous_song(self, *args):
app.player.previous()
def __rebuild(self, activator, force):
scan_library(self.__library, force)
# Set up the preferences window.
def __preferences(self, activator):
window = PreferencesWindow(self)
window.show()
def __plugins(self, activator):
window = PluginWindow(self)
window.show()
def open_location(self, action):
name = GetStringDialog(self, _("Add a Location"),
_("Enter the location of an audio file:"),
button_label=_("_Add"), button_icon=Icons.LIST_ADD).run()
if name:
if not uri_is_valid(name):
ErrorMessage(
self, _("Unable to add location"),
_("%s is not a valid location.") % (
util.bold(util.escape(name)))).run()
elif not app.player.can_play_uri(name):
ErrorMessage(
self, _("Unable to add location"),
_("%s uses an unsupported protocol.") % (
util.bold(util.escape(name)))).run()
else:
if name not in self.__library:
self.__library.add([RemoteFile(name)])
def open_chooser(self, action):
if action.get_name() == "AddFolders":
fns = choose_folders(self, _("Add Music"), _("_Add Folders"))
if fns:
# scan them
copool.add(self.__library.scan, fns, cofuncid="library",
funcid="library")
else:
patterns = ["*" + path2fsn(k) for k in formats.loaders.keys()]
choose_filter = create_chooser_filter(_("Music Files"), patterns)
fns = choose_files(
self, _("Add Music"), _("_Add Files"), choose_filter)
if fns:
for filename in fns:
self.__library.add_filename(filename)
def __songs_popup_menu(self, songlist):
path, col = songlist.get_cursor()
header = col.header_name
menu = self.songlist.Menu(header, self.browser, self.__library)
if menu is not None:
return self.songlist.popup_menu(menu, 0,
Gtk.get_current_event_time())
def __current_song_prop(self, *args):
song = app.player.song
if song:
librarian = self.__library.librarian
window = SongProperties(librarian, [song], parent=self)
window.show()
def __current_song_info(self, *args):
song = app.player.song
if song:
librarian = self.__library.librarian
window = Information(librarian, [song], self)
window.show()
def __browser_activate(self, browser):
app.player._reset()
def __browser_cb(self, browser, songs, sorted, library, player):
if browser.background:
bg = background_filter()
if bg:
songs = list(filter(bg, songs))
self.songlist.set_songs(songs, sorted)
# After the first time the browser activates, which should always
# happen if we start up and restore, restore the playing song.
# Because the browser has send us songs we can be sure it has
# registered all its libraries.
if self.__first_browser_set:
self.__first_browser_set = False
song = library.librarian.get(config.get("memory", "song"))
seek_pos = config.getfloat("memory", "seek", 0)
config.set("memory", "seek", 0)
if song is not None:
player.setup(self.playlist, song, seek_pos)
if self.__restore_cb:
self.__restore_cb()
self.__restore_cb = None
def __hide_headers(self, activator=None):
for column in self.songlist.get_columns():
if self.browser.headers is None:
column.set_visible(True)
else:
for tag in util.tagsplit(column.header_name):
if tag in self.browser.headers:
column.set_visible(True)
break
else:
column.set_visible(False)
def __cols_changed(self, songlist):
headers = [col.header_name for col in songlist.get_columns()]
try:
headers.remove('~current')
except ValueError:
pass
if len(headers) == len(get_columns()):
# Not an addition or removal (handled separately)
set_columns(headers)
SongList.headers = headers
def __make_query(self, query):
if self.browser.can_filter_text():
self.browser.filter_text(query.encode('utf-8'))
self.browser.activate()
def __set_totals(self, info, songs):
length = sum(song.get("~#length", 0) for song in songs)
t = self.browser.status_text(count=len(songs),
time=util.format_time_preferred(length))
self.statusbar.set_default_text(t)
