def test_get_set_columns(self):
self.failIf(config.get("settings", "headers", None))
self.failIf(config.get("settings", "columns", None))
columns = ["first", "won't", "two words", "4"]
config.set_columns(columns)
# First assume caching
self.failUnlessEqual(columns, config.get_columns())
# Then without
self.failUnlessEqual(columns, config.get_columns(refresh=True))
columns += ["~~another~one"]
# Test dirtying the cache
config.set_columns(columns)
self.failUnlessEqual(columns, config.get_columns())
self.failUnlessEqual(columns, config.get_columns(refresh=True))
self.failIf(config.get("settings", "headers", None))
def __apply(self, button, buttons, tiv, aip, fip, aio):
new_headers = set()
# Get the checked headers
for key, name in self.PREDEFINED_TAGS:
if buttons[key].get_active():
new_headers.add(key)
# And the customs
new_headers.update(set(self.other_cols))
on_to_off = dict((on, off) for (w, off, on) in self._toggle_data)
result = []
cur_cols = config.get_columns(refresh=True)
for h in cur_cols:
if h in new_headers:
result.append(h)
else:
try:
alternative = on_to_off[h]
if alternative in new_headers:
result.append(alternative)
except KeyError:
pass
# Add new ones on the end
result.extend(new_headers - set(result))
# After this, do the substitutions
for (check, off, on) in self._toggle_data:
if check.get_active():
try:
result[result.index(off)] = on
except ValueError:
pass
SongList.set_all_column_headers(result)
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_columns()):
# Not an addition or removal (handled separately)
config.set_columns(headers)
SongList.headers = headers
def test_get_columns_migrates(self):
self.failIf(config.get("settings", "headers", None))
self.failIf(config.get("settings", "columns", None))
headers = "~album ~#replaygain_track_gain foobar"
config.set("settings", "headers", headers)
columns = config.get_columns(headers)
self.failUnlessEqual(columns,
["~album", "~#replaygain_track_gain", "foobar"])
self.failIf(config.get("settings", "headers", None))
def to_html(songs):
cols = config.get_columns()
cols_s = ""
for col in cols:
cols_s += '<th>%s</th>' % tag(col)
songs_s = ""
for song in songs:
s = '<tr>'
for col in cols:
col = {"~#rating": "~rating", "~#length": "~length"}.get(col, col)
s += '\n<td>%s</td>' % (escape(unicode(song.comma(col)))
or ' ')
s += '</tr>'
songs_s += s
return HTML % {'headers': cols_s, 'songs': songs_s}
def __init__(self):
super(PreferencesWindow.SongList, self).__init__(spacing=12)
self.set_border_width(12)
self.title = _("Song List")
# Behaviour
vbox = Gtk.VBox(spacing=6)
c = CCB(_("_Jump to playing song automatically"),
'settings',
'jump',
populate=True,
tooltip=_("When the playing song changes, "
"scroll to it in the song list"))
vbox.pack_start(c, False, True, 0)
frame = qltk.Frame(_("Behavior"), child=vbox)
self.pack_start(frame, False, True, 0)
# Columns
vbox = Gtk.VBox(spacing=12)
buttons = {}
table = Gtk.Table.new(3, 3, True)
cols = config.get_columns(refresh=True)
for i, (k, t) in enumerate(self.PREDEFINED_TAGS):
x, y = i % 3, i / 3
buttons[k] = Gtk.CheckButton(label=t, use_underline=True)
if k in cols:
buttons[k].set_active(True)
cols.remove(k)
table.attach(buttons[k], x, x + 1, y, y + 1)
vbox.pack_start(table, False, True, 0)
if "~current" in cols:
cols.remove("~current")
self.other_cols = cols
# Other columns
hbox = Gtk.HBox(spacing=6)
l = Gtk.Label(label=_("_Others:"), use_underline=True)
hbox.pack_start(l, False, True, 0)
self.others = others = UndoEntry()
others.set_sensitive(False)
# Stock edit doesn't have ellipsis chars.
edit_button = Gtk.Button(label=_("_Edit..."), use_underline=True)
edit_button.connect("clicked", self.__config_cols)
edit_button.set_tooltip_text(
_("Add or remove additional column "
"headers"))
l.set_mnemonic_widget(edit_button)
l.set_use_underline(True)
hbox.pack_start(others, True, True, 0)
hbox.pack_start(edit_button, False, True, 0)
vbox.pack_start(hbox, False, True, 0)
frame = qltk.Frame(_("Visible Columns"), child=vbox)
self.pack_start(frame, False, True, 0)
# Column preferences
tiv = Gtk.CheckButton(label=_("Title includes _version"),
use_underline=True)
aio = Gtk.CheckButton(label=_("Artist includes all _people"),
use_underline=True)
aip = Gtk.CheckButton(label=_("Album includes _disc subtitle"),
use_underline=True)
fip = Gtk.CheckButton(label=_("Filename includes _folder"),
use_underline=True)
self._toggle_data = [(tiv, "title", "~title~version"),
(aip, "album", "~album~discsubtitle"),
(fip, "~basename", "~filename"),
(aio, "artist", "~people")]
# Turn on the toggles if the toggled version is detected in config
for (check, off, on) in self._toggle_data:
if on in cols:
buttons[off].set_active(True)
check.set_active(True)
cols.remove(on)
# Update text once to exclude ticked columns, munged or not
others.set_text(", ".join(cols))
t = Gtk.Table.new(2, 2, True)
t.attach(tiv, 0, 1, 0, 1)
t.attach(aip, 0, 1, 1, 2)
t.attach(aio, 1, 2, 0, 1)
t.attach(fip, 1, 2, 1, 2)
frame = qltk.Frame(_("Column Preferences"), child=t)
self.pack_start(frame, False, True, 0)
# Apply button
vbox = Gtk.VBox(spacing=12)
apply = Gtk.Button(stock=Gtk.STOCK_APPLY)
apply.set_tooltip_text(
_("Apply current configuration to song "
"list, adding new columns to the end"))
b = Gtk.HButtonBox()
b.set_layout(Gtk.ButtonBoxStyle.END)
b.pack_start(apply, True, True, 0)
vbox.pack_start(b, True, True, 0)
self.pack_start(vbox, True, True, 0)
apply.connect('clicked', self.__apply, buttons, tiv, aip, fip, aio)
# Apply on destroy, else config gets mangled
self.connect('destroy', self.__apply, buttons, tiv, aip, fip, aio)
for child in self.get_children():
child.show_all()
def main():
process_arguments()
from quodlibet import const
if isrunning() and not const.DEBUG:
print_(_("Quod Libet is already running."))
control('focus')
import quodlibet
quodlibet._init_signal()
import quodlibet.player
from quodlibet import app
from quodlibet import config
from quodlibet import browsers
from quodlibet import const
from quodlibet import util
config.init(const.CONFIG)
library = quodlibet.init(library=const.LIBRARY,
icon="quodlibet",
name="Quod Libet",
title=const.PROCESS_TITLE_QL)
app.library = library
from quodlibet.player import PlayerError
for backend in [config.get("player", "backend"), "nullbe"]:
try:
player = quodlibet.init_backend(backend, app.librarian)
except PlayerError as error:
print_e("%s. %s" % (error.short_desc, error.long_desc))
else:
break
app.player = player
os.environ["PULSE_PROP_media.role"] = "music"
os.environ["PULSE_PROP_application.icon_name"] = "quodlibet"
browsers.init()
from quodlibet.qltk.songlist import SongList
from quodlibet.util.collection import Album
try:
cover_size = config.getint("browsers", "cover_size")
except config.Error:
pass
else:
if cover_size > 0:
Album.COVER_SIZE = cover_size
headers = config.get_columns()
SongList.set_all_column_headers(headers)
for opt in config.options("header_maps"):
val = config.get("header_maps", opt)
util.tags.add(opt, val)
in_all = ("~filename ~uri ~#lastplayed ~#rating ~#playcount ~#skipcount "
"~#added ~#bitrate ~current ~#laststarted ~basename "
"~dirname").split()
for Kind in browsers.browsers:
if Kind.headers is not None:
Kind.headers.extend(in_all)
Kind.init(library)
pm = quodlibet.init_plugins(no_plugins)
if hasattr(player, "init_plugins"):
player.init_plugins()
from quodlibet.qltk import unity
unity.init("quodlibet.desktop", player)
from quodlibet.qltk.songsmenu import SongsMenu
SongsMenu.init_plugins()
from quodlibet.util.cover.manager import cover_plugins
cover_plugins.init_plugins()
from quodlibet.plugins.playlist import PLAYLIST_HANDLER
PLAYLIST_HANDLER.init_plugins()
from quodlibet.qltk.quodlibetwindow import QuodLibetWindow
app.window = window = QuodLibetWindow(library, player)
from quodlibet.plugins.events import EventPluginHandler
pm.register_handler(EventPluginHandler(library.librarian, player))
from quodlibet.qltk import mmkeys_ as mmkeys
from quodlibet.qltk.remote import FSInterface, FIFOControl
from quodlibet.qltk.tracker import SongTracker
try:
from quodlibet.qltk.dbus_ import DBusHandler
except ImportError:
DBusHandler = lambda player, library: None
mmkeys.init(window, player)
fsiface = FSInterface(player)
quodlibet.quit_add(1, fsiface.destroy)
fifoctrl = FIFOControl(app)
quodlibet.quit_add(1, fifoctrl.destroy)
DBusHandler(player, library)
SongTracker(library.librarian, player, window.playlist)
from quodlibet.qltk import session
session.init("quodlibet")
quodlibet.enable_periodic_save(save_library=True)
if play:
player.paused = False
# restore browser windows
from quodlibet.qltk.browser import LibraryBrowser
from gi.repository import GLib
GLib.idle_add(LibraryBrowser.restore, library, priority=GLib.PRIORITY_HIGH)
quodlibet.main(window)
print_d("Shutting down player device %r." % player.version_info)
player.destroy()
quodlibet.library.save(force=True)
config.save(const.CONFIG)
print_d("Finished shutdown.")