def PluginPreferences(self, parent):
box = Gtk.HBox()
ccb = ConfigCheckButton(_("Hide main window on close"),
'plugins', 'mpris_window_hide')
ccb.set_active(self.__do_hide())
box.pack_start(qltk.Frame(_("Preferences"), child=ccb), True, True, 0)
return box
def PluginPreferences(self, parent):
box = Gtk.HBox()
ccb = ConfigCheckButton(_("Hide main window on close"), 'plugins',
'mpris_window_hide')
ccb.set_active(self.__do_hide())
box.pack_start(qltk.Frame(_("Preferences"), child=ccb), True, True, 0)
return box
def test_toggle(self):
config.set("memory", "bar", "on")
c = ConfigCheckButton("dummy", "memory", "bar")
c.set_active(True)
self.failUnless(config.getboolean("memory", "bar") and c.get_active())
c.set_active(False)
run_gtk_loop()
self.failIf(config.getboolean("memory", "bar") or c.get_active())
def test_toggle(self):
config.set("memory", "bar", "on")
c = ConfigCheckButton("dummy", "memory", "bar")
c.set_active(True)
self.failUnless(config.getboolean("memory", "bar") and c.get_active())
c.set_active(False)
while gtk.events_pending(): gtk.main_iteration()
self.failIf(config.getboolean("memory", "bar") or c.get_active())
def test_toggle(self):
config.set("memory", "bar", "on")
c = ConfigCheckButton("dummy", "memory", "bar")
c.set_active(True)
self.failUnless(config.getboolean("memory", "bar") and c.get_active())
c.set_active(False)
while Gtk.events_pending():
Gtk.main_iteration()
self.failIf(config.getboolean("memory", "bar") or c.get_active())
def PluginPreferences(self):
box = Gtk.HBox()
ccb = ConfigCheckButton(
_("Automatically start playing "
"double-clicked songs"), 'plugins', 'queue_only_autoplay')
autoplay = config.getboolean('plugins', 'queue_only_autoplay', False)
ccb.set_active(autoplay)
box.pack_start(qltk.Frame(_("Preferences"), child=ccb), True, True, 0)
return box
def PluginPreferences(self, parent):
prefer_lbl = _("Store cover into the directory of song")
prefer_key = 'prefer_song_dir'
grid = Gtk.Grid.new()
prefer_cb = ConfigCheckButton(prefer_lbl, 'albumart', prefer_key)
prefer_cb.set_active(config.getboolean('albumart', prefer_key, False))
grid.attach(prefer_cb, 0, 0, 1, 1)
return grid
def PluginPreferences(self, win):
vb = Gtk.VBox()
vb.set_spacing(8)
ccb = ConfigCheckButton(
_("Write _standard MusicBrainz tags"),
"plugins", "fingerprint_write_mb_tags")
ccb.set_active(get_write_mb_tags())
vb.pack_start(ccb, True, True, 0)
return vb
def __init__(self, parent):
if self.is_not_unique(): return
super(Preferences, self).__init__()
self.set_border_width(12)
self.set_title(_("Album List Preferences") + " - Quod Libet")
self.set_default_size(400, 270)
self.set_transient_for(qltk.get_top_parent(parent))
box = gtk.VBox(spacing=6)
cb = ConfigCheckButton(
_("Show album _covers"), "browsers", "album_covers")
cb.set_active(config.getboolean("browsers", "album_covers"))
gobject_weak(cb.connect, 'toggled', lambda s: AlbumList.toggle_covers())
box.pack_start(cb, expand=False)
cb = ConfigCheckButton(
_("Inline _search includes people"),
"browsers", "album_substrings")
cb.set_active(config.getboolean("browsers", "album_substrings"))
box.pack_start(cb, expand=False)
vbox = gtk.VBox(spacing=6)
label = gtk.Label()
label.set_alignment(0.0, 0.5)
edit = PatternEditBox(PATTERN)
edit.text = AlbumList._pattern_text
gobject_weak(edit.apply.connect, 'clicked', self.__set_pattern, edit)
gobject_weak(edit.buffer.connect_object, 'changed',
self.__preview_pattern, edit, label, parent=edit)
vbox.pack_start(label, expand=False)
vbox.pack_start(edit)
self.__preview_pattern(edit, label)
f = qltk.Frame(_("Album Display"), child=vbox)
box.pack_start(f)
main_box = gtk.VBox(spacing=12)
close = gtk.Button(stock=gtk.STOCK_CLOSE)
close.connect('clicked', lambda *x: self.destroy())
b = gtk.HButtonBox()
b.set_layout(gtk.BUTTONBOX_END)
b.pack_start(close)
main_box.pack_start(box)
main_box.pack_start(b, expand=False)
self.add(main_box)
close.grab_focus()
self.show_all()
def PluginPreferences(self, win):
items = [
('split_disc', 'Split _disc from album', True),
('tesbtnlub', 'blbla_ sdfsadfsaf asdf', False),
# ('year_only', 'Only use year for "date" tag', False),
]
vb = gtk.VBox()
vb.set_spacing(8)
for key, label, default in items:
ccb = ConfigCheckButton(label, 'plugins', 'discogs_' + key)
ccb.set_active(config_get(key, default))
vb.pack_start(ccb)
return vb
def __init__(self, browser):
if self.is_not_unique():
return
super(Preferences, self).__init__()
self.set_border_width(12)
self.set_title(_("Album List Preferences"))
self.set_default_size(420, 380)
self.set_transient_for(qltk.get_top_parent(browser))
# Do this config-driven setup at instance-time
self._PREVIEW_ITEM["~rating"] = format_rating(0.75)
box = Gtk.VBox(spacing=6)
vbox = Gtk.VBox(spacing=6)
cb = ConfigCheckButton(
_("Show album _covers"), "browsers", "album_covers")
cb.set_active(config.getboolean("browsers", "album_covers"))
cb.connect('toggled', lambda s: browser.toggle_covers())
vbox.pack_start(cb, False, True, 0)
cb = ConfigCheckButton(
_("Inline _search includes people"),
"browsers", "album_substrings")
cb.set_active(config.getboolean("browsers", "album_substrings"))
vbox.pack_start(cb, False, True, 0)
f = qltk.Frame(_("Options"), child=vbox)
box.pack_start(f, False, True, 12)
display_frame = self.edit_display_pane(browser, _("Album Display"))
box.pack_start(display_frame, True, True, 0)
main_box = Gtk.VBox(spacing=12)
close = Button(_("_Close"), Icons.WINDOW_CLOSE)
close.connect('clicked', lambda *x: self.destroy())
b = Gtk.HButtonBox()
b.set_layout(Gtk.ButtonBoxStyle.END)
b.pack_start(close, True, True, 0)
main_box.pack_start(box, True, True, 0)
self.use_header_bar()
if not self.has_close_button():
main_box.pack_start(b, False, True, 0)
self.add(main_box)
close.grab_focus()
self.show_all()
def __init__(self, browser):
if self.is_not_unique():
return
super(Preferences, self).__init__()
self.set_border_width(12)
self.set_title(_("Album List Preferences"))
self.set_default_size(420, 380)
self.set_transient_for(qltk.get_top_parent(browser))
# Do this config-driven setup at instance-time
self._PREVIEW_ITEM["~rating"] = format_rating(0.75)
box = Gtk.VBox(spacing=6)
vbox = Gtk.VBox(spacing=6)
cb = ConfigCheckButton(
_("Show album _covers"), "browsers", "album_covers")
cb.set_active(config.getboolean("browsers", "album_covers"))
cb.connect('toggled', lambda s: browser.toggle_covers())
vbox.pack_start(cb, False, True, 0)
cb = ConfigCheckButton(
_("Inline _search includes people"),
"browsers", "album_substrings")
cb.set_active(config.getboolean("browsers", "album_substrings"))
vbox.pack_start(cb, False, True, 0)
f = qltk.Frame(_("Options"), child=vbox)
box.pack_start(f, False, True, 12)
display_frame = self.edit_display_pane(browser, _("Album Display"))
box.pack_start(display_frame, True, True, 0)
main_box = Gtk.VBox(spacing=12)
close = Button(_("_Close"), Icons.WINDOW_CLOSE)
close.connect('clicked', lambda *x: self.destroy())
b = Gtk.HButtonBox()
b.set_layout(Gtk.ButtonBoxStyle.END)
b.pack_start(close, True, True, 0)
main_box.pack_start(box, True, True, 0)
self.use_header_bar()
if not self.has_close_button():
main_box.pack_start(b, False, True, 0)
self.add(main_box)
close.grab_focus()
self.show_all()
def PluginPreferences(cls, window):
# Plugin Options
toggles = [
(cls._CFG_SEEKABLE_ONLY, _("Only Seekable Sources")),
]
vb = Gtk.VBox(spacing=10)
vb.set_border_width(0)
vb2 = Gtk.VBox(spacing=6)
for key, label in toggles:
ccb = ConfigCheckButton(label, 'plugins', cls._config_key(key))
ccb.set_active(cls.config_get_bool(key))
vb2.pack_start(ccb, True, True, 0)
frame = qltk.Frame(label=_("Plugin Options"), child=vb2)
vb.pack_start(frame, False, True, 0)
vb.show_all()
return vb
def __init__(self, parent):
if self.is_not_unique():
return
super(PreferencesWindow, self).__init__()
self.set_title(_("Ex Falso Preferences"))
self.set_border_width(12)
self.set_resizable(False)
self.set_transient_for(parent)
vbox = Gtk.VBox(spacing=6)
hb = Gtk.HBox(spacing=6)
e = UndoEntry()
e.set_text(config.get("editing", "split_on"))
e.connect('changed', self.__changed, 'editing', 'split_on')
l = Gtk.Label(label=_("Split _on:"))
l.set_use_underline(True)
l.set_mnemonic_widget(e)
hb.pack_start(l, False, True, 0)
hb.pack_start(e, True, True, 0)
cb = ConfigCheckButton(
_("Show _programmatic tags"),
'editing',
'alltags',
tooltip=_("Access all tags, including machine-generated "
"ones e.g. MusicBrainz or Replay Gain tags"))
cb.set_active(config.getboolean("editing", 'alltags'))
vbox.pack_start(hb, False, True, 0)
vbox.pack_start(cb, False, True, 0)
f = qltk.Frame(_("Tag Editing"), child=vbox)
close = Gtk.Button(stock=Gtk.STOCK_CLOSE)
close.connect_object('clicked', lambda x: x.destroy(), self)
button_box = Gtk.HButtonBox()
button_box.set_layout(Gtk.ButtonBoxStyle.END)
button_box.pack_start(close, True, True, 0)
main_vbox = Gtk.VBox(spacing=12)
main_vbox.pack_start(f, True, True, 0)
main_vbox.pack_start(button_box, False, True, 0)
self.add(main_vbox)
self.connect_object('destroy', PreferencesWindow.__destroy, self)
self.get_child().show_all()
def PluginPreferences(self, win):
items = [
('split_disc', 'Split _disc from album', True),
('split_feat', 'Split _featured performers from track', False),
('year_only', 'Only use year for "date" tag', False),
('albumartist', 'Write "_albumartist" when needed', True),
('artist_sort', 'Write sort tags for artist names', False),
('standard', 'Write _standard MusicBrainz tags', True),
('labelid', 'Write _labelid tag (fixes multi-disc albums)', True),
]
vb = Gtk.VBox()
vb.set_spacing(8)
for key, label, default in items:
ccb = ConfigCheckButton(label, 'plugins', 'brainz_' + key)
ccb.set_active(config_get(key, default))
vb.pack_start(ccb, True, True, 0)
return vb
def PluginPreferences(cls, window):
def key_changed(entry):
cls.key_expression = None
cls.config_set(cls._CFG_KEY_KEY, entry.get_text().strip())
vb = Gtk.VBox(spacing=10)
vb.set_border_width(0)
hbox = Gtk.HBox(spacing=6)
# TODO: construct a decent validator and use ValidatingEntry
e = UndoEntry()
e.set_text(cls.get_key_expression())
e.connect("changed", key_changed)
e.set_tooltip_markup(
_("Accepts QL tag expressions like "
"<tt>~artist~title</tt> or <tt>musicbrainz_track_id</tt>"))
lbl = Gtk.Label(label=_("_Group duplicates by:"))
lbl.set_mnemonic_widget(e)
lbl.set_use_underline(True)
hbox.pack_start(lbl, False, True, 0)
hbox.pack_start(e, True, True, 0)
frame = qltk.Frame(label=_("Duplicate Key"), child=hbox)
vb.pack_start(frame, True, True, 0)
# Matching Option
toggles = [
(cls._CFG_REMOVE_WHITESPACE, _("Remove _Whitespace")),
(cls._CFG_REMOVE_DIACRITICS, _("Remove _Diacritics")),
(cls._CFG_REMOVE_PUNCTUATION, _("Remove _Punctuation")),
(cls._CFG_CASE_INSENSITIVE, _("Case _Insensitive")),
]
vb2 = Gtk.VBox(spacing=6)
for key, label in toggles:
ccb = ConfigCheckButton(label, 'plugins', cls._config_key(key))
ccb.set_active(cls.config_get_bool(key))
vb2.pack_start(ccb, True, True, 0)
frame = qltk.Frame(label=_("Matching options"), child=vb2)
vb.pack_start(frame, False, True, 0)
vb.show_all()
return vb
def PluginPreferences(self, win):
items = [
('split_disc', _('Split _disc from album'), True),
('split_feat', _('Split _featured performers from track'), False),
('year_only', _('Only use year for "date" tag'), False),
('albumartist', _('Write "_albumartist" when needed'), True),
('artist_sort', _('Write sort tags for artist names'), False),
('standard', _('Write _standard MusicBrainz tags'), True),
('labelid',
_('Write _labelid tag (fixes multi-disc albums)'), True),
]
vb = Gtk.VBox()
vb.set_spacing(8)
for key, label, default in items:
ccb = ConfigCheckButton(label, 'plugins', 'brainz_' + key)
ccb.set_active(config_get(key, default))
vb.pack_start(ccb, True, True, 0)
return vb
def PluginPreferences(cls, window):
def key_changed(entry):
cls.key_expression = None
cls.config_set(cls._CFG_KEY_KEY, entry.get_text().strip())
vb = Gtk.VBox(spacing=10)
vb.set_border_width(0)
hbox = Gtk.HBox(spacing=6)
# TODO: construct a decent validator and use ValidatingEntry
e = UndoEntry()
e.set_text(cls.get_key_expression())
e.connect("changed", key_changed)
e.set_tooltip_markup(_("Accepts QL tag expressions like "
"<tt>~artist~title</tt> or <tt>musicbrainz_track_id</tt>"))
lbl = Gtk.Label(label=_("_Group duplicates by:"))
lbl.set_mnemonic_widget(e)
lbl.set_use_underline(True)
hbox.pack_start(lbl, False, True, 0)
hbox.pack_start(e, True, True, 0)
frame = qltk.Frame(label=_("Duplicate Key"), child=hbox)
vb.pack_start(frame, True, True, 0)
# Matching Option
toggles = [
(cls._CFG_REMOVE_WHITESPACE, _("Remove _Whitespace")),
(cls._CFG_REMOVE_DIACRITICS, _("Remove _Diacritics")),
(cls._CFG_REMOVE_PUNCTUATION, _("Remove _Punctuation")),
(cls._CFG_CASE_INSENSITIVE, _("Case _Insensitive")),
]
vb2 = Gtk.VBox(spacing=6)
for key, label in toggles:
ccb = ConfigCheckButton(label, 'plugins', cls._config_key(key))
ccb.set_active(cls.config_get_bool(key))
vb2.pack_start(ccb, True, True, 0)
frame = qltk.Frame(label=_("Matching options"), child=vb2)
vb.pack_start(frame, False, True, 0)
vb.show_all()
return vb
def __init__(self, parent):
if self.is_not_unique(): return
super(PreferencesWindow, self).__init__()
self.set_title(_("Ex Falso Preferences"))
self.set_border_width(12)
self.set_resizable(False)
self.set_transient_for(parent)
vbox = gtk.VBox(spacing=6)
hb = gtk.HBox(spacing=6)
e = UndoEntry()
e.set_text(config.get("editing", "split_on"))
e.connect('changed', self.__changed, 'editing', 'split_on')
l = gtk.Label(_("Split _on:"))
l.set_use_underline(True)
l.set_mnemonic_widget(e)
hb.pack_start(l, expand=False)
hb.pack_start(e)
cb = ConfigCheckButton(
_("Show _programmatic tags"), 'editing', 'alltags')
cb.set_active(config.getboolean("editing", 'alltags'))
vbox.pack_start(hb, expand=False)
vbox.pack_start(cb, expand=False)
f = qltk.Frame(_("Tag Editing"), child=vbox)
close = gtk.Button(stock=gtk.STOCK_CLOSE)
close.connect_object('clicked', lambda x: x.destroy(), self)
button_box = gtk.HButtonBox()
button_box.set_layout(gtk.BUTTONBOX_END)
button_box.pack_start(close)
main_vbox = gtk.VBox(spacing=12)
main_vbox.pack_start(f)
main_vbox.pack_start(button_box, expand=False)
self.add(main_vbox)
self.connect_object('destroy', PreferencesWindow.__destroy, self)
self.show_all()
def PluginPreferences(self, *args):
hb = Gtk.HBox(spacing=6)
label = Gtk.Label(label=_("_Theme:"))
combo = Gtk.ComboBoxText()
theme = config.get("plugins", self.CONFIG_THEME, None)
combo.append_text(_("Default Theme"))
themes = self.__get_themes()
select = 0
for i, name in enumerate(sorted(themes)):
combo.append_text(name)
if name == theme:
select = i + 1
combo.set_active(select)
combo.connect('changed', self.__changed)
dark_button = ConfigCheckButton(_("Prefer dark theme version"),
"plugins", self.CONFIG_DARK)
dark_button.set_active(
config.getboolean("plugins", self.CONFIG_DARK, False))
def dark_cb(button):
self.__set_dark(button.get_active())
dark_button.connect('toggled', dark_cb)
label.set_mnemonic_widget(combo)
label.set_use_underline(True)
hb.pack_start(label, False, True, 0)
hb.pack_start(combo, False, True, 0)
vbox = Gtk.VBox(spacing=6)
vbox.pack_start(hb, False, True, 0)
vbox.pack_start(dark_button, False, True, 0)
return qltk.Frame(_("Preferences"), child=vbox)
def __init__(self, browser):
if self.is_not_unique():
return
super().__init__()
self.set_border_width(12)
self.set_title(_("Cover Grid Preferences"))
self.set_default_size(420, 380)
self.set_transient_for(qltk.get_top_parent(browser))
# Do this config-driven setup at instance-time
self._PREVIEW_ITEM["~rating"] = format_rating(0.75)
self.mag_lock = False
box = Gtk.VBox(spacing=6)
vbox = Gtk.VBox(spacing=6)
cb = ConfigCheckButton(_("Show album _text"), "browsers", "album_text")
cb.set_active(config.getboolean("browsers", "album_text"))
cb.connect('toggled', lambda s: browser.toggle_text())
vbox.pack_start(cb, False, True, 0)
cb2 = ConfigCheckButton(_("Show \"All Albums\" Item"), "browsers",
"covergrid_all")
cb2.set_active(config.getboolean("browsers", "covergrid_all", True))
def refilter(s):
mod = browser.view.get_model()
if mod:
mod.refilter()
cb2.connect('toggled', refilter)
vbox.pack_start(cb2, False, True, 0)
cb3 = ConfigCheckButton(_("Wide Mode"), "browsers", "covergrid_wide")
cb3.set_active(config.getboolean("browsers", "covergrid_wide", False))
cb3.connect('toggled', lambda s: browser.toggle_wide())
vbox.pack_start(cb3, False, True, 0)
# Redraws the covers only when the user releases the slider
def mag_button_press(*_):
self.mag_lock = True
def mag_button_release(mag, _):
self.mag_lock = False
mag_changed(mag)
def mag_changed(mag):
if self.mag_lock:
return
newmag = mag.get_value()
oldmag = config.getfloat("browsers", "covergrid_magnification", 3.)
if newmag == oldmag:
print_d("Covergrid magnification haven't changed: {0}".format(
newmag))
return
print_d('Covergrid magnification update from {0} to {1}'.format(
oldmag, newmag))
config.set("browsers", "covergrid_magnification", mag.get_value())
browser.update_mag()
mag_scale = Gtk.HScale(adjustment=Gtk.Adjustment.new(
config.getfloat("browsers", "covergrid_magnification", 3), 0., 10.,
.5, .5, 0))
mag_scale.set_tooltip_text(_("Cover Magnification"))
l = Gtk.Label(label=_("Cover Magnification"))
mag_scale.set_value_pos(Gtk.PositionType.RIGHT)
mag_scale.connect('button-press-event', mag_button_press)
mag_scale.connect('button-release-event', mag_button_release)
mag_scale.connect('value-changed', mag_changed)
vbox.pack_start(l, False, True, 0)
vbox.pack_start(mag_scale, False, True, 0)
f = qltk.Frame(_("Options"), child=vbox)
box.pack_start(f, False, True, 12)
display_frame = self.edit_display_pane(browser, _("Album Display"))
box.pack_start(display_frame, True, True, 0)
main_box = Gtk.VBox(spacing=12)
close = Button(_("_Close"), Icons.WINDOW_CLOSE)
close.connect('clicked', lambda *x: self.destroy())
b = Gtk.HButtonBox()
b.set_layout(Gtk.ButtonBoxStyle.END)
b.pack_start(close, True, True, 0)
main_box.pack_start(box, True, True, 0)
self.use_header_bar()
if not self.has_close_button():
main_box.pack_start(b, False, True, 0)
self.add(main_box)
close.grab_focus()
self.show_all()
def __init__(self, menu, library, player):
super(QueueExpander, self).__init__()
sw = ScrolledWindow()
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
sw.set_shadow_type(gtk.SHADOW_IN)
self.queue = PlayQueue(library, player)
sw.add(self.queue)
hb = gtk.HBox(spacing=12)
hb2 = gtk.HBox(spacing=3)
state = gtk.image_new_from_stock(
gtk.STOCK_MEDIA_STOP, gtk.ICON_SIZE_MENU)
hb2.pack_start(state)
l = gtk.Label(_("_Queue"))
hb2.pack_start(l)
hb.pack_start(hb2)
l.set_use_underline(True)
clear = gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_MENU)
b = gtk.Button()
b.add(clear)
b.set_tooltip_text(_("Remove all songs from the queue"))
b.connect('clicked', self.__clear_queue)
b.hide()
b.set_relief(gtk.RELIEF_NONE)
hb.pack_start(b, expand=False, fill=False)
l2 = gtk.Label()
hb.pack_start(l2)
cb = ConfigCheckButton(
_("_Random"), "memory", "shufflequeue")
cb.connect('toggled', self.__queue_shuffle, self.queue.model)
cb.set_active(config.getboolean("memory", "shufflequeue"))
hb.pack_start(cb)
self.set_label_widget(hb)
self.add(sw)
self.connect_object('notify::expanded', self.__expand, cb, b)
targets = [("text/x-quodlibet-songs", gtk.TARGET_SAME_APP, 1),
("text/uri-list", 0, 2)]
self.drag_dest_set(gtk.DEST_DEFAULT_ALL, targets, gtk.gdk.ACTION_COPY)
self.connect('drag-motion', self.__motion)
self.connect('drag-data-received', self.__drag_data_received)
self.model = self.queue.model
self.show_all()
self.queue.model.connect_after('row-inserted',
util.DeferredSignal(self.__check_expand), l2)
self.queue.model.connect_after('row-deleted',
util.DeferredSignal(self.__update_count), l2)
cb.hide()
self.connect_object('notify::visible', self.__visible, cb, menu, b)
self.__update_count(self.model, None, l2)
player.connect('song-started', self.__update_state_icon, state)
player.connect('paused', self.__update_state_icon_pause,
state, gtk.STOCK_MEDIA_PAUSE)
player.connect('unpaused', self.__update_state_icon_pause,
state, gtk.STOCK_MEDIA_PLAY)
# to make the children clickable if mapped
# ....no idea why, but works
def hack(expander):
label = expander.get_label_widget()
if label:
label.unmap()
label.map()
self.connect("map", hack)
def __init__(self, browser):
if self.is_not_unique():
return
super(Preferences, self).__init__()
self.set_border_width(12)
self.set_title(_("Cover Grid Preferences"))
self.set_default_size(420, 380)
self.set_transient_for(qltk.get_top_parent(browser))
# Do this config-driven setup at instance-time
self._PREVIEW_ITEM["~rating"] = format_rating(0.75)
self.mag_lock = False
box = Gtk.VBox(spacing=6)
vbox = Gtk.VBox(spacing=6)
cb = ConfigCheckButton(
_("Show album _text"), "browsers", "album_text")
cb.set_active(config.getboolean("browsers", "album_text"))
cb.connect('toggled',
lambda s: browser.toggle_text())
vbox.pack_start(cb, False, True, 0)
cb2 = ConfigCheckButton(
_("Show \"All Albums\" Item"), "browsers", "covergrid_all")
cb2.set_active(config.getboolean("browsers", "covergrid_all", False))
cb2.connect('toggled',
lambda s: browser.view.get_model().refilter())
vbox.pack_start(cb2, False, True, 0)
cb3 = ConfigCheckButton(
_("Wide Mode"), "browsers", "covergrid_wide")
cb3.set_active(config.getboolean("browsers",
"covergrid_wide", False))
cb3.connect('toggled',
lambda s: browser.toggle_wide())
vbox.pack_start(cb3, False, True, 0)
# Redraws the covers only when the user releases the slider
def mag_button_press(*_):
self.mag_lock = True
def mag_button_release(mag, _):
self.mag_lock = False
mag_changed(mag)
def mag_changed(mag):
if self.mag_lock:
return
newmag = mag.get_value()
oldmag = config.getfloat("browsers", "covergrid_magnification", 3.)
if newmag == oldmag:
print_d("Covergrid magnification haven't changed: {0}"
.format(newmag))
return
print_d('Covergrid magnification update from {0} to {1}'
.format(oldmag, newmag))
config.set("browsers", "covergrid_magnification", mag.get_value())
browser.update_mag()
mag_scale = Gtk.HScale(
adjustment=Gtk.Adjustment.new(config.getfloat("browsers",
"covergrid_magnification", 3), 0., 10., .5, .5, 0))
mag_scale.set_tooltip_text(_("Cover Magnification"))
l = Gtk.Label(label=_("Cover Magnification"))
mag_scale.set_value_pos(Gtk.PositionType.RIGHT)
mag_scale.connect('button-press-event', mag_button_press)
mag_scale.connect('button-release-event', mag_button_release)
mag_scale.connect('value-changed', mag_changed)
vbox.pack_start(l, False, True, 0)
vbox.pack_start(mag_scale, False, True, 0)
f = qltk.Frame(_("Options"), child=vbox)
box.pack_start(f, False, True, 12)
display_frame = self.edit_display_pane(browser, _("Album Display"))
box.pack_start(display_frame, True, True, 0)
main_box = Gtk.VBox(spacing=12)
close = Button(_("_Close"), Icons.WINDOW_CLOSE)
close.connect('clicked', lambda *x: self.destroy())
b = Gtk.HButtonBox()
b.set_layout(Gtk.ButtonBoxStyle.END)
b.pack_start(close, True, True, 0)
main_box.pack_start(box, True, True, 0)
self.use_header_bar()
if not self.has_close_button():
main_box.pack_start(b, False, True, 0)
self.add(main_box)
close.grab_focus()
self.show_all()
def __init__(self, songs, title=None):
super(SearchWindow, self).__init__(default_width=800, default_height=400, border_width=12, title=title)
self._thread = AcoustidLookupThread(self.__lookup_cb)
sw = Gtk.ScrolledWindow()
sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
sw.set_shadow_type(Gtk.ShadowType.IN)
model = ObjectStore()
self.view = view = ResultView()
view.set_model(model)
self.model = model
self._iter_map = {}
for song in songs:
iter_ = self.model.append([SearchEntry(song)])
self._iter_map[song] = iter_
sw.add(view)
self.pool = pool = FingerPrintPool()
pool.connect("fingerprint-done", self.__fp_done_cb)
pool.connect("fingerprint-error", self.__fp_error_cb)
pool.connect("fingerprint-started", self.__fp_started_cb)
for song in songs:
pool.push(song)
outer_box = Gtk.VBox(spacing=12)
bbox = Gtk.HButtonBox()
bbox.set_layout(Gtk.ButtonBoxStyle.END)
bbox.set_spacing(6)
self.__save = save = Button(_("_Save"), Icons.DOCUMENT_SAVE)
save.connect("clicked", self.__on_save)
save.set_sensitive(False)
cancel = Button(_("_Cancel"))
cancel.connect("clicked", lambda *x: self.destroy())
bbox.pack_start(save, True, True, 0)
bbox.pack_start(cancel, True, True, 0)
inner_box = Gtk.VBox(spacing=6)
inner_box.pack_start(sw, True, True, 0)
ccb = ConfigCheckButton(_("Write MusicBrainz tags"), "plugins", "fingerprint_write_mb_tags")
ccb.set_active(get_write_mb_tags())
inner_box.pack_start(ccb, False, True, 0)
ccb = ConfigCheckButton(_("Group by directory"), "plugins", "fingerprint_group_by_dir")
ccb.set_active(get_group_by_dir())
ccb.connect("toggled", self.__group_toggled)
self._group_ccb = ccb
outer_box.pack_start(inner_box, True, True, 0)
bottom_box = Gtk.HBox(spacing=12)
mode_button = Gtk.ToggleButton(label=_("Album Mode"))
mode_button.set_tooltip_text(
_("Write album related tags and try to " "reduce the number of different album releases")
)
mode_button.set_active(True)
mode_button.connect("toggled", self.__mode_toggle)
bottom_box.pack_start(mode_button, False, True, 0)
bottom_box.pack_start(self._group_ccb, False, True, 0)
bottom_box.pack_start(bbox, True, True, 0)
outer_box.pack_start(bottom_box, False, True, 0)
outer_box.show_all()
self.add(outer_box)
self.__album_mode = True
self.__group_by_dir = True
self._release_scores = {}
self._directory_scores = {}
self.__done = 0
self.connect("destroy", self.__destroy)
def __init__(self, activator):
super(Preferences, self).__init__(spacing=12)
self.set_border_width(6)
ccb = ConfigCheckButton(_("Hide main window on close"), 'plugins',
'trayicon_window_hide')
ccb.set_active(get_hide_window())
self.pack_start(ccb, False, True, 0)
combo = Gtk.ComboBoxText()
combo.append_text(
_("Scroll wheel adjusts volume\n"
"Shift and scroll wheel changes song"))
combo.append_text(
_("Scroll wheel changes song\n"
"Shift and scroll wheel adjusts volume"))
combo.set_active(
int(config.getboolean("plugins", "icon_modifier_swap", False)))
combo.connect('changed', self.__changed_combo)
self.pack_start(qltk.Frame(_("Scroll _Wheel"), child=combo), True,
True, 0)
box = Gtk.VBox(spacing=12)
table = Gtk.Table(n_rows=2, n_columns=4)
table.set_row_spacings(6)
table.set_col_spacings(12)
cbs = []
for i, tag in enumerate([
"genre", "artist", "album", "discnumber", "part",
"tracknumber", "title", "version"
]):
cb = Gtk.CheckButton(label=util.tag(tag))
cb.tag = tag
cbs.append(cb)
table.attach(cb, i % 3, i % 3 + 1, i // 3, i // 3 + 1)
box.pack_start(table, True, True, 0)
entry = Gtk.Entry()
box.pack_start(entry, False, True, 0)
preview = Gtk.Label()
preview.set_ellipsize(Pango.EllipsizeMode.END)
ev = Gtk.EventBox()
ev.add(preview)
box.pack_start(ev, False, True, 0)
frame = qltk.Frame(_("Tooltip Display"), child=box)
frame.get_label_widget().set_mnemonic_widget(entry)
self.pack_start(frame, True, True, 0)
for cb in cbs:
cb.connect('toggled', self.__changed_cb, cbs, entry)
entry.connect('changed', self.__changed_entry, cbs, preview)
try:
entry.set_text(config.get("plugins", "icon_tooltip"))
except:
entry.set_text(
"<album|<album~discnumber~part~tracknumber~title~version>|"
"<artist~title~version>>")
for child in self.get_children():
child.show_all()
def __init__(self, activator):
super(Preferences, self).__init__(spacing=12)
self.set_border_width(6)
ccb = ConfigCheckButton(_("Hide main window on close"),
'plugins', 'trayicon_window_hide')
ccb.set_active(get_hide_window())
self.pack_start(ccb, False, True, 0)
combo = Gtk.ComboBoxText()
combo.append_text(_("Scroll wheel adjusts volume\n"
"Shift and scroll wheel changes song"))
combo.append_text(_("Scroll wheel changes song\n"
"Shift and scroll wheel adjusts volume"))
combo.set_active(int(
config.getboolean("plugins", "icon_modifier_swap", False)))
combo.connect('changed', self.__changed_combo)
self.pack_start(qltk.Frame(_("Scroll _Wheel"), child=combo),
True, True, 0)
box = Gtk.VBox(spacing=12)
table = Gtk.Table(n_rows=2, n_columns=4)
table.set_row_spacings(6)
table.set_col_spacings(12)
cbs = []
for i, tag in enumerate([
"genre", "artist", "album", "discnumber", "part",
"tracknumber", "title", "version"]):
cb = Gtk.CheckButton(label=util.tag(tag))
cb.tag = tag
cbs.append(cb)
table.attach(cb, i % 3, i % 3 + 1, i // 3, i // 3 + 1)
box.pack_start(table, True, True, 0)
entry = Gtk.Entry()
box.pack_start(entry, False, True, 0)
preview = Gtk.Label()
preview.set_ellipsize(Pango.EllipsizeMode.END)
ev = Gtk.EventBox()
ev.add(preview)
box.pack_start(ev, False, True, 0)
frame = qltk.Frame(_("Tooltip Display"), child=box)
frame.get_label_widget().set_mnemonic_widget(entry)
self.pack_start(frame, True, True, 0)
for cb in cbs:
cb.connect('toggled', self.__changed_cb, cbs, entry)
entry.connect(
'changed', self.__changed_entry, cbs, preview)
try:
entry.set_text(config.get("plugins", "icon_tooltip"))
except:
entry.set_text(
"<album|<album~discnumber~part~tracknumber~title~version>|"
"<artist~title~version>>")
for child in self.get_children():
child.show_all()
def __init__(self, browser):
if self.is_not_unique():
return
super(Preferences, self).__init__()
self.set_border_width(12)
self.set_title(_("Album List Preferences") + " - Quod Libet")
self.set_default_size(420, 380)
self.set_transient_for(qltk.get_top_parent(browser))
# Do this config-driven setup at instance-time
self._EXAMPLE_ALBUM["~rating"] = format_rating(0.75)
box = Gtk.VBox(spacing=6)
vbox = Gtk.VBox(spacing=6)
cb = ConfigCheckButton(
_("Show album _covers"), "browsers", "album_covers")
cb.set_active(config.getboolean("browsers", "album_covers"))
cb.connect('toggled', lambda s: browser.toggle_covers())
vbox.pack_start(cb, False, True, 0)
cb = ConfigCheckButton(
_("Inline _search includes people"),
"browsers", "album_substrings")
cb.set_active(config.getboolean("browsers", "album_substrings"))
vbox.pack_start(cb, False, True, 0)
f = qltk.Frame(_("Options"), child=vbox)
box.pack_start(f, False, True, 12)
vbox = Gtk.VBox(spacing=6)
label = Gtk.Label()
label.set_alignment(0.0, 0.5)
label.set_padding(6, 6)
eb = Gtk.EventBox()
eb.get_style_context().add_class("entry")
eb.add(label)
edit = PatternEditBox(PATTERN)
edit.text = browser._pattern_text
edit.apply.connect('clicked', self.__set_pattern, edit, browser)
connect_obj(
edit.buffer, 'changed', self.__preview_pattern, edit, label)
vbox.pack_start(eb, False, True, 3)
vbox.pack_start(edit, True, True, 0)
self.__preview_pattern(edit, label)
f = qltk.Frame(_("Album Display"), child=vbox)
box.pack_start(f, True, True, 0)
main_box = Gtk.VBox(spacing=12)
close = Button(_("_Close"), Icons.WINDOW_CLOSE)
close.connect('clicked', lambda *x: self.destroy())
b = Gtk.HButtonBox()
b.set_layout(Gtk.ButtonBoxStyle.END)
b.pack_start(close, True, True, 0)
main_box.pack_start(box, True, True, 0)
self.use_header_bar()
if not self.has_close_button():
main_box.pack_start(b, False, True, 0)
self.add(main_box)
close.grab_focus()
self.show_all()
def __init__(self, songs, title=None):
super().__init__(
default_width=800, default_height=400, border_width=12,
title=title)
self._thread = AcoustidLookupThread(self.__lookup_cb)
sw = Gtk.ScrolledWindow()
sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
sw.set_shadow_type(Gtk.ShadowType.IN)
model = ObjectStore()
self.view = view = ResultView()
view.set_model(model)
self.model = model
self._iter_map = {}
for song in songs:
iter_ = self.model.append([SearchEntry(song)])
self._iter_map[song] = iter_
sw.add(view)
self.pool = pool = FingerPrintPool()
pool.connect('fingerprint-done', self.__fp_done_cb)
pool.connect('fingerprint-error', self.__fp_error_cb)
pool.connect('fingerprint-started', self.__fp_started_cb)
for song in songs:
pool.push(song)
outer_box = Gtk.VBox(spacing=12)
bbox = Gtk.HButtonBox()
bbox.set_layout(Gtk.ButtonBoxStyle.END)
bbox.set_spacing(6)
self.__save = save = Button(_("_Save"), Icons.DOCUMENT_SAVE)
save.connect("clicked", self.__on_save)
save.set_sensitive(False)
cancel = Button(_("_Cancel"))
cancel.connect("clicked", lambda *x: self.destroy())
bbox.pack_start(save, True, True, 0)
bbox.pack_start(cancel, True, True, 0)
inner_box = Gtk.VBox(spacing=6)
inner_box.pack_start(sw, True, True, 0)
ccb = ConfigCheckButton(
_("Write MusicBrainz tags"),
"plugins", "fingerprint_write_mb_tags")
ccb.set_active(get_write_mb_tags())
inner_box.pack_start(ccb, False, True, 0)
ccb = ConfigCheckButton(
_("Group by directory"),
"plugins", "fingerprint_group_by_dir")
ccb.set_active(get_group_by_dir())
ccb.connect("toggled", self.__group_toggled)
self._group_ccb = ccb
outer_box.pack_start(inner_box, True, True, 0)
bottom_box = Gtk.HBox(spacing=12)
mode_button = Gtk.ToggleButton(label=_("Album Mode"))
mode_button.set_tooltip_text(
_("Write album related tags and try to "
"reduce the number of different album releases"))
mode_button.set_active(True)
mode_button.connect("toggled", self.__mode_toggle)
bottom_box.pack_start(mode_button, False, True, 0)
bottom_box.pack_start(self._group_ccb, False, True, 0)
bottom_box.pack_start(bbox, True, True, 0)
outer_box.pack_start(bottom_box, False, True, 0)
outer_box.show_all()
self.add(outer_box)
self.__album_mode = True
self.__group_by_dir = True
self._release_scores = {}
self._directory_scores = {}
self.__done = 0
self.connect("destroy", self.__destroy)
def __init__(self, library, player):
super(QueueExpander, self).__init__(spacing=3)
sw = ScrolledWindow()
sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
sw.set_shadow_type(Gtk.ShadowType.IN)
self.queue = PlayQueue(library, player)
self.queue.props.expand = True
sw.add(self.queue)
add_css(self, ".ql-expanded title { margin-bottom: 5px; }")
outer = ExpandBoxHack(spacing=12)
left = Gtk.HBox(spacing=12)
hb2 = Gtk.HBox(spacing=3)
state_icon = PlaybackStatusIcon()
state_icon.stop()
state_icon.show()
hb2.pack_start(state_icon, True, True, 0)
name_label = Gtk.Label(label=_("_Queue"), use_underline=True)
hb2.pack_start(name_label, True, True, 0)
left.pack_start(hb2, False, True, 0)
b = SmallImageButton(
image=SymbolicIconImage(Icons.EDIT_CLEAR, Gtk.IconSize.MENU))
b.set_tooltip_text(_("Remove all songs from the queue"))
b.connect('clicked', self.__clear_queue)
b.set_no_show_all(True)
b.set_relief(Gtk.ReliefStyle.NONE)
left.pack_start(b, False, False, 0)
self.count_label = count_label = Gtk.Label()
left.pack_start(count_label, False, True, 0)
outer.pack_start(left, True, True, 0)
close_button = SmallImageButton(
image=SymbolicIconImage("window-close", Gtk.IconSize.MENU),
relief=Gtk.ReliefStyle.NONE)
close_button.connect("clicked", lambda *x: self.hide())
outer.pack_start(close_button, False, False, 6)
self.set_label_fill(True)
cb = ConfigCheckButton(
_("_Random"), "memory", "shufflequeue")
cb.connect('toggled', self.__queue_shuffle, self.queue.model)
cb.set_active(config.getboolean("memory", "shufflequeue"))
cb.set_no_show_all(True)
left.pack_start(cb, False, True, 0)
self.set_label_widget(outer)
self.add(sw)
connect_obj(self, 'notify::expanded', self.__expand, cb, b)
targets = [
("text/x-quodlibet-songs", Gtk.TargetFlags.SAME_APP, DND_QL),
("text/uri-list", 0, 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-motion', self.__motion)
self.connect('drag-data-received', self.__drag_data_received)
self.queue.model.connect_after('row-inserted',
util.DeferredSignal(self.__check_expand), count_label)
self.queue.model.connect_after('row-deleted',
util.DeferredSignal(self.__update_count), count_label)
connect_obj(self, 'notify::visible', self.__visible, cb, b)
self.__update_count(self.model, None, count_label)
connect_destroy(
player, 'song-started', self.__update_state_icon, state_icon)
connect_destroy(
player, 'paused', self.__update_state_icon_pause,
state_icon, True)
connect_destroy(
player, 'unpaused', self.__update_state_icon_pause,
state_icon, False)
# to make the children clickable if mapped
# ....no idea why, but works
def hack(expander):
label = expander.get_label_widget()
if label:
label.unmap()
label.map()
self.connect("map", hack)
self.set_expanded(config.getboolean("memory", "queue_expanded"))
self.notify("expanded")
for child in self.get_children():
child.show_all()
def __init__(self, menu, library, player):
super(QueueExpander, self).__init__()
sw = ScrolledWindow()
sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
sw.set_shadow_type(Gtk.ShadowType.IN)
self.queue = PlayQueue(library, player)
sw.add(self.queue)
outer = Gtk.HBox(spacing=12)
left = Gtk.HBox(spacing=12)
hb2 = Gtk.HBox(spacing=3)
state_icon = PlaybackStatusIcon()
state_icon.stop()
state_icon.show()
hb2.pack_start(state_icon, True, True, 0)
name_label = Gtk.Label(label=_("_Queue"), use_underline=True)
hb2.pack_start(name_label, True, True, 0)
left.pack_start(hb2, False, True, 0)
b = SmallImageButton(
image=Gtk.Image.new_from_stock(Gtk.STOCK_CLEAR, Gtk.IconSize.MENU))
b.set_tooltip_text(_("Remove all songs from the queue"))
b.connect('clicked', self.__clear_queue)
b.hide()
b.set_relief(Gtk.ReliefStyle.NONE)
left.pack_start(b, False, False, 0)
count_label = Gtk.Label()
left.pack_start(count_label, False, True, 0)
outer.pack_start(left, True, True, 0)
close_button = SmallImageButton(image=SymbolicIconImage(
"window-close", Gtk.IconSize.MENU),
relief=Gtk.ReliefStyle.NONE)
close_button.connect("clicked", lambda *x: self.hide())
outer.pack_start(close_button, False, False, 6)
self.set_label_fill(True)
cb = ConfigCheckButton(_("_Random"), "memory", "shufflequeue")
cb.connect('toggled', self.__queue_shuffle, self.queue.model)
cb.set_active(config.getboolean("memory", "shufflequeue"))
left.pack_start(cb, False, True, 0)
self.set_label_widget(outer)
self.add(sw)
self.connect_object('notify::expanded', self.__expand, cb, b)
targets = [("text/x-quodlibet-songs", Gtk.TargetFlags.SAME_APP,
DND_QL), ("text/uri-list", 0, 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-motion', self.__motion)
self.connect('drag-data-received', self.__drag_data_received)
self.show_all()
self.queue.model.connect_after(
'row-inserted', util.DeferredSignal(self.__check_expand),
count_label)
self.queue.model.connect_after(
'row-deleted', util.DeferredSignal(self.__update_count),
count_label)
cb.hide()
self.connect_object('notify::visible', self.__visible, cb, menu, b)
self.__update_count(self.model, None, count_label)
player.connect('song-started', self.__update_state_icon, state_icon)
player.connect('paused', self.__update_state_icon_pause, state_icon,
True)
player.connect('unpaused', self.__update_state_icon_pause, state_icon,
False)
# to make the children clickable if mapped
# ....no idea why, but works
def hack(expander):
label = expander.get_label_widget()
if label:
label.unmap()
label.map()
self.connect("map", hack)
def PluginPreferences(self, parent):
# Check if the queries file exists
if not os.path.exists(self.path_query):
return self._no_queries_frame()
# Read saved searches from file
self.queries = {}
with open(self.path_query, 'r', encoding='utf-8') as query_file:
for query_string in query_file:
name = next(query_file).strip()
self.queries[name] = Query(query_string.strip())
if not self.queries:
# query_file is empty
return self._no_queries_frame()
main_vbox = Gtk.VBox(spacing=self.spacing_main)
self.main_vbox = main_vbox
# Saved search selection frame
saved_search_vbox = Gtk.VBox(spacing=self.spacing_large)
self.saved_search_vbox = saved_search_vbox
for query_name, query in self.queries.items():
query_config = self.CONFIG_QUERY_PREFIX + query_name
check_button = ConfigCheckButton(query_name, PM.CONFIG_SECTION,
self._config_key(query_config))
check_button.set_active(self.config_get_bool(query_config))
saved_search_vbox.pack_start(check_button, False, False, 0)
saved_search_scroll = self._expandable_scroll(min_h=0, max_h=300)
saved_search_scroll.add(saved_search_vbox)
frame = qltk.Frame(
label=_('Synchronize the following saved searches:'),
child=saved_search_scroll)
main_vbox.pack_start(frame, False, False, 0)
# Destination path entry field
destination_entry = Gtk.Entry(
placeholder_text=_('The absolute path to your export location'),
text=config.get(PM.CONFIG_SECTION, self.CONFIG_PATH_KEY, ''))
destination_entry.connect('changed', self._destination_path_changed)
self.destination_entry = destination_entry
# Destination path selection button
destination_button = qltk.Button(label='', icon_name=Icons.FOLDER_OPEN)
destination_button.connect('clicked', self._select_destination_path)
# Destination path hbox
destination_path_hbox = Gtk.HBox(spacing=self.spacing_small)
destination_path_hbox.pack_start(destination_entry, True, True, 0)
destination_path_hbox.pack_start(destination_button, False, False, 0)
# Destination path information
destination_warn_label = self._label_with_icon(
_("All pre-existing files in the destination folder that aren't in "
"the saved searches will be deleted."), Icons.DIALOG_WARNING)
destination_info_label = self._label_with_icon(
_('For devices mounted with MTP, export to a local destination '
'folder, then transfer it to your device with rsync. '
'Or, when syncing many files to an Android Device, use adb-sync, '
'which is much faster.'), Icons.DIALOG_INFORMATION)
# Destination path frame
destination_vbox = Gtk.VBox(spacing=self.spacing_large)
destination_vbox.pack_start(destination_path_hbox, False, False, 0)
destination_vbox.pack_start(destination_warn_label, False, False, 0)
destination_vbox.pack_start(destination_info_label, False, False, 0)
frame = qltk.Frame(label=_('Destination path:'),
child=destination_vbox)
main_vbox.pack_start(frame, False, False, 0)
# Export pattern frame
export_pattern_combo = ComboBoxEntrySave(
self.path_pattern, [self.default_export_pattern],
title=_('Path Patterns'),
edit_title=_(u'Edit saved patterns…'))
export_pattern_combo.enable_clear_button()
export_pattern_combo.show_all()
export_pattern_entry = export_pattern_combo.get_child()
export_pattern_entry.set_placeholder_text(
_('The structure of the exported filenames, based on their tags'))
export_pattern_entry.set_text(
config.get(PM.CONFIG_SECTION, self.CONFIG_PATTERN_KEY,
self.default_export_pattern))
export_pattern_entry.connect('changed', self._export_pattern_changed)
self.export_pattern_entry = export_pattern_entry
frame = qltk.Frame(label=_('Export pattern:'),
child=export_pattern_combo)
main_vbox.pack_start(frame, False, False, 0)
# Start preview button
preview_start_button = qltk.Button(label=_('Preview'),
icon_name=Icons.VIEW_REFRESH)
preview_start_button.set_visible(True)
preview_start_button.connect('clicked', self._start_preview)
self.preview_start_button = preview_start_button
# Stop preview button
preview_stop_button = qltk.Button(label=_('Stop preview'),
icon_name=Icons.PROCESS_STOP)
preview_stop_button.set_visible(False)
preview_stop_button.set_no_show_all(True)
preview_stop_button.connect('clicked', self._stop_preview)
self.preview_stop_button = preview_stop_button
# Details view
column_types = [column[1] for column in self.model_cols.values()]
self.model = Gtk.ListStore(*column_types)
self.details_tree = details_tree = HintedTreeView(model=self.model)
details_scroll = self._expandable_scroll()
details_scroll.set_shadow_type(Gtk.ShadowType.IN)
details_scroll.add(details_tree)
self.renders = {}
# Preview column: status
render = Gtk.CellRendererText()
column = self._tree_view_column(render,
self._cdf_status,
title=_('Status'),
expand=False,
sort=self._model_col_id('tag'))
details_tree.append_column(column)
# Preview column: file
render = Gtk.CellRendererText()
column = self._tree_view_column(render,
self._cdf_source_path,
title=_('Source File'),
sort=self._model_col_id('filename'))
details_tree.append_column(column)
# Preview column: export path
render = Gtk.CellRendererText()
render.set_property('editable', True)
render.connect('edited', self._row_edited)
column = self._tree_view_column(render,
self._cdf_export_path,
title=_('Export Path'),
sort=self._model_col_id('export'))
details_tree.append_column(column)
# Status labels
self.status_operation = Gtk.Label(xalign=0.0,
yalign=0.5,
wrap=True,
visible=False,
no_show_all=True)
self.status_progress = Gtk.Label(xalign=0.0,
yalign=0.5,
wrap=True,
visible=False,
no_show_all=True)
self.status_duplicates = self._label_with_icon(_(
'Duplicate export paths detected! The export paths above can be '
'edited before starting the synchronization.'),
Icons.DIALOG_WARNING,
visible=False)
self.status_deletions = self._label_with_icon(
_('Existing files in the destination path will be deleted!'),
Icons.DIALOG_WARNING,
visible=False)
# Section for previewing exported files
preview_vbox = Gtk.VBox(spacing=self.spacing_large)
preview_vbox.pack_start(preview_start_button, False, False, 0)
preview_vbox.pack_start(preview_stop_button, False, False, 0)
preview_vbox.pack_start(details_scroll, True, True, 0)
preview_vbox.pack_start(self.status_operation, False, False, 0)
preview_vbox.pack_start(self.status_progress, False, False, 0)
preview_vbox.pack_start(self.status_duplicates, False, False, 0)
preview_vbox.pack_start(self.status_deletions, False, False, 0)
main_vbox.pack_start(preview_vbox, True, True, 0)
# Start sync button
sync_start_button = qltk.Button(label=_('Start synchronization'),
icon_name=Icons.DOCUMENT_SAVE)
sync_start_button.set_sensitive(False)
sync_start_button.set_visible(True)
sync_start_button.connect('clicked', self._start_sync)
self.sync_start_button = sync_start_button
# Stop sync button
sync_stop_button = qltk.Button(label=_('Stop synchronization'),
icon_name=Icons.PROCESS_STOP)
sync_stop_button.set_visible(False)
sync_stop_button.set_no_show_all(True)
sync_stop_button.connect('clicked', self._stop_sync)
self.sync_stop_button = sync_stop_button
# Section for the sync buttons
sync_vbox = Gtk.VBox(spacing=self.spacing_large)
sync_vbox.pack_start(sync_start_button, False, False, 0)
sync_vbox.pack_start(sync_stop_button, False, False, 0)
main_vbox.pack_start(sync_vbox, False, False, 0)
return main_vbox
def __init__(self, browser):
if self.is_not_unique():
return
super(Preferences, self).__init__()
self.set_border_width(12)
self.set_title(_("Album List Preferences") + " - Quod Libet")
self.set_default_size(420, 380)
self.set_transient_for(qltk.get_top_parent(browser))
# Do this config-driven setup at instance-time
self._EXAMPLE_ALBUM["~rating"] = format_rating(0.75)
box = Gtk.VBox(spacing=6)
vbox = Gtk.VBox(spacing=6)
cb = ConfigCheckButton(_("Show album _covers"), "browsers",
"album_covers")
cb.set_active(config.getboolean("browsers", "album_covers"))
cb.connect('toggled', lambda s: browser.toggle_covers())
vbox.pack_start(cb, False, True, 0)
cb = ConfigCheckButton(_("Inline _search includes people"), "browsers",
"album_substrings")
cb.set_active(config.getboolean("browsers", "album_substrings"))
vbox.pack_start(cb, False, True, 0)
f = qltk.Frame(_("Options"), child=vbox)
box.pack_start(f, False, True, 12)
vbox = Gtk.VBox(spacing=6)
label = Gtk.Label()
label.set_alignment(0.0, 0.5)
label.set_padding(6, 6)
eb = Gtk.EventBox()
eb.get_style_context().add_class("entry")
eb.add(label)
edit = PatternEditBox(PATTERN)
edit.text = browser._pattern_text
edit.apply.connect('clicked', self.__set_pattern, edit, browser)
connect_obj(edit.buffer, 'changed', self.__preview_pattern, edit,
label)
vbox.pack_start(eb, False, True, 3)
vbox.pack_start(edit, True, True, 0)
self.__preview_pattern(edit, label)
f = qltk.Frame(_("Album Display"), child=vbox)
box.pack_start(f, True, True, 0)
main_box = Gtk.VBox(spacing=12)
close = Gtk.Button(stock=Gtk.STOCK_CLOSE)
close.connect('clicked', lambda *x: self.destroy())
b = Gtk.HButtonBox()
b.set_layout(Gtk.ButtonBoxStyle.END)
b.pack_start(close, True, True, 0)
main_box.pack_start(box, True, True, 0)
self.use_header_bar()
if not self.has_close_button():
main_box.pack_start(b, False, True, 0)
self.add(main_box)
close.grab_focus()
self.show_all()
def PluginPreferences(self, parent):
vbox = Gtk.VBox(spacing=6)
queries = {}
query_path = os.path.join(get_user_dir(), 'lists', 'queries.saved')
with open(query_path, 'rU', encoding='utf-8') as query_file:
for query_string in query_file:
name = next(query_file).strip()
queries[name] = Query(query_string.strip())
for query_name, query in queries.items():
check_button = ConfigCheckButton((query_name), "plugins",
self._config_key(query_name))
check_button.set_active(self.config_get_bool(query_name))
vbox.pack_start(check_button, False, True, 0)
chooserButton = Gtk.FileChooserButton(_('Select destination folder'))
chooserButton.set_current_folder(self.lastfolder)
chooserButton.set_action(Gtk.FileChooserAction.SELECT_FOLDER)
# https://stackoverflow.com/a/14742779/109813
def get_actual_filename(name):
# Do nothing except on Windows
if os.name != 'nt':
return name
dirs = name.split('\\')
# disk letter
test_name = [dirs[0].upper()]
for d in dirs[1:]:
test_name += ["%s[%s]" % (d[:-1], d[-1])]
res = glob.glob('\\'.join(test_name))
if not res:
# File not found, return the input
return name
return res[0]
def __file_error(file_path):
qltk.ErrorMessage(
None, _("Unable to export playlist"),
_("Writing to <b>%s</b> failed.") %
util.escape(file_path)).run()
def __m3u_export(dir_path, query_name, songs):
file_path = os.path.join(dir_path, query_name + '.m3u')
try:
fhandler = open(file_path, "wb")
except IOError:
__file_error(file_path)
else:
text = "#EXTM3U\n"
for song in songs:
title = "%s - %s" % (song('~people').replace(
"\n", ", "), song('~title~version'))
path = song('~filename')
path = get_actual_filename(path)
try:
path = relpath(path, dir_path)
except ValueError:
# Keep absolute path
pass
text += "#EXTINF:%d,%s\n" % (song('~#length'), title)
text += path + "\n"
fhandler.write(text.encode("utf-8"))
fhandler.close()
def __start(button):
target_folder = chooserButton.get_filename()
songs = app.library.get_content()
for query_name, query in queries.items():
if self.config_get_bool(query_name):
# Query is enabled
songs_for_query = query.filter(songs)
__m3u_export(target_folder, query_name, songs_for_query)
message = qltk.Message(Gtk.MessageType.INFO, app.window, _("Done"),
_("Export finished."))
message.run()
start_button = Gtk.Button(label=("Export"))
start_button.connect('clicked', __start)
vbox.pack_start(chooserButton, True, True, 0)
vbox.pack_start(start_button, True, True, 0)
label = Gtk.Label(
label=
"Quod Libet may become unresponsive. You will get a message when finished."
)
vbox.pack_start(label, True, True, 0)
return qltk.Frame(("Select the saved searches to copy:"), child=vbox)
def PluginPreferences(cls, parent):
vb = Gtk.VBox(spacing=12)
# Tabulate all settings for neatness
table = Gtk.Table(n_rows=1, n_columns=2)
table.set_col_spacings(6)
table.set_row_spacings(6)
rows = []
def process_option_changed(combo):
#xcode = combo.get_child().get_text()
model = combo.get_model()
lbl, value = model[combo.get_active()]
cls.config_set("process_if", value)
def create_model():
model = Gtk.ListStore(str, str)
model.append(["<b>%s</b>" % _("always"), UpdateMode.ALWAYS])
model.append([_("if <b>any</b> RG tags are missing"),
UpdateMode.ANY_MISSING])
model.append([_("if <b>album</b> RG tags are missing"),
UpdateMode.ALBUM_MISSING])
return model
def set_active(value):
for i, item in enumerate(model):
if value == item[1]:
combo.set_active(i)
model = create_model()
combo = Gtk.ComboBox(model=model)
set_active(cls.config_get("process_if", PrefDefaults.update_mode))
renderer = Gtk.CellRendererText()
combo.connect('changed', process_option_changed)
combo.pack_start(renderer, True)
combo.add_attribute(renderer, "markup", 0)
rows.append((_("_Process albums:"), combo))
for (row, (label_text, entry)) in enumerate(rows):
label = Gtk.Label(label=label_text)
label.set_alignment(0.0, 0.5)
label.set_use_underline(True)
label.set_mnemonic_widget(entry)
table.attach(label, 0, 1, row, row + 1,
xoptions=Gtk.AttachOptions.FILL)
table.attach(entry, 1, 2, row, row + 1)
# Processing Options
frame = Frame(_("Processing Options"), table)
vb.pack_start(frame, True, True, 0)
# Options
toggles = [
('write_rl', _("Store _reference loudness"),
PrefDefaults.write_rl),
('delete_unused', _("_Delete tags that this scanner doesn't use"),
PrefDefaults.delete_unused),
('never_overwrite', _("_Never overwrite existing tags"),
PrefDefaults.never_overwrite),
]
vb2 = Gtk.VBox(spacing=6)
for key, label, dv in toggles:
ccb = ConfigCheckButton(label, 'plugins', cls._config_key(key))
ccb.set_active(cls.config_get_bool(key, dv))
vb2.pack_start(ccb, True, True, 0)
frame2 = Frame(_("Misc Options"), vb2)
vb.pack_start(frame2, False, True, 0)
return vb