def pattern(pat, cap=True, esc=False, markup=False):
"""Return a 'natural' version of the pattern string for human-readable
bits. Assumes all tags in the pattern are present.
"""
from quodlibet.pattern import Pattern, XMLFromPattern, XMLFromMarkupPattern
class Fakesong(dict):
cap = False
def comma(self, key):
return " - ".join(self.list(key))
def list(self, key):
return [tag(k, self.cap) for k in tagsplit(key)]
list_separate = list
def __call__(self, tag, *args):
return 0 if '~#' in tag[:2] else self.comma(tag)
fakesong = Fakesong({'filename': tag('filename', cap)})
fakesong.cap = cap
try:
if markup:
p = XMLFromMarkupPattern(pat)
elif esc:
p = XMLFromPattern(pat)
else:
p = Pattern(pat)
except ValueError:
return _("Invalid pattern")
return p.format(fakesong)
def pattern(pat, cap=True, esc=False, markup=False):
"""Return a 'natural' version of the pattern string for human-readable
bits. Assumes all tags in the pattern are present.
"""
from quodlibet.pattern import Pattern, XMLFromPattern, XMLFromMarkupPattern
class Fakesong(dict):
cap = False
def comma(self, key):
return " - ".join(self.list(key))
def list(self, key):
return [tag(k, self.cap) for k in tagsplit(key)]
list_separate = list
def __call__(self, tag, *args):
return 0 if '~#' in tag[:2] else self.comma(tag)
fakesong = Fakesong({'filename': tag('filename', cap)})
fakesong.cap = cap
try:
if markup:
p = XMLFromMarkupPattern(pat)
elif esc:
p = XMLFromPattern(pat)
else:
p = Pattern(pat)
except ValueError:
return _("Invalid pattern")
return p.format(fakesong)
def test_convenience(s):
pat = XMLFromMarkupPattern(r'[b]foo[/b]')
s.assertEquals(pat.format(s.a), '<b>foo</b>')
s._test_markup(pat.format(s.a))
pat = XMLFromMarkupPattern('[small ]foo[/small \t]')
s.assertEquals(pat.format(s.a), '<small >foo</small \t>')
s._test_markup(pat.format(s.a))
def test_span(s):
pat = XMLFromMarkupPattern(r'[span]foo[/span]')
s.assertEquals(pat.format(s.a), '<span>foo</span>')
s._test_markup(pat.format(s.a))
pat = XMLFromMarkupPattern(r'[span weight="bold"]foo[/span]')
s.assertEquals(pat.format(s.a), '<span weight="bold">foo</span>')
s._test_markup(pat.format(s.a))
def test_escape(s):
pat = XMLFromMarkupPattern(r'\[b]')
s.assertEquals(pat.format(s.a), '[b]')
s._test_markup(pat.format(s.a))
pat = XMLFromMarkupPattern(r'\\[b]\\[/b]')
s.assertEquals(pat.format(s.a), r'\<b>\</b>')
s._test_markup(pat.format(s.a))
def __init__(self, library, player, pattern_filename):
super(SongInfo, self).__init__()
self._pattern_filename = pattern_filename
self.set_visible_window(False)
align = Align(halign=Gtk.Align.START, valign=Gtk.Align.START)
label = Gtk.Label()
label.set_ellipsize(Pango.EllipsizeMode.MIDDLE)
label.set_track_visited_links(False)
label.set_selectable(True)
align.add(label)
label.set_alignment(0.0, 0.0)
self._label = label
connect_destroy(library, 'changed', self._on_library_changed, player)
connect_destroy(player, 'song-started', self._on_song_started)
label.connect('populate-popup', self._on_label_popup, player, library)
self.connect('button-press-event', self._on_button_press_event, player,
library)
try:
with open(self._pattern_filename, "rb") as h:
self._pattern = h.read().strip().decode("utf-8")
except (EnvironmentError, UnicodeDecodeError):
pass
self._compiled = XMLFromMarkupPattern(self._pattern)
align.show_all()
self.add(align)
def init(klass, library):
try:
klass._pattern_text = file(PATTERN_FN).read().rstrip()
except EnvironmentError:
klass._pattern_text = PATTERN
klass._pattern = XMLFromMarkupPattern(klass._pattern_text)
def init(klass, library):
try:
with open(PATTERN_FN, "r") as f:
klass._pattern_text = f.read().rstrip()
except EnvironmentError:
klass._pattern_text = PATTERN
klass._pattern = XMLFromMarkupPattern(klass._pattern_text)
def refresh_pattern(klass, pattern_text):
if pattern_text == klass._pattern_text:
return
klass._pattern_text = pattern_text
klass._pattern = XMLFromMarkupPattern(pattern_text)
klass.__model.refresh_all()
pattern_fn = PATTERN_FN
with open(pattern_fn, "w") as f:
f.write(pattern_text + "\n")
def refresh_pattern(klass, pattern_text):
if pattern_text == klass._pattern_text:
return
klass._pattern_text = pattern_text
klass._pattern = XMLFromMarkupPattern(pattern_text)
klass.__model.refresh_all()
pattern_fn = PATTERN_FN
f = file(pattern_fn, "w")
f.write(pattern_text + "\n")
f.close()
def test_escape(s):
pat = XMLFromMarkupPattern(r'\[b]')
s.assertEquals(pat.format(s.a), '[b]')
s._test_markup(pat.format(s.a))
pat = XMLFromMarkupPattern(r'\\[b]\\[/b]')
s.assertEquals(pat.format(s.a), r'\<b>\</b>')
s._test_markup(pat.format(s.a))
def test_convenience(s):
pat = XMLFromMarkupPattern(r'[b]foo[/b]')
s.assertEquals(pat.format(s.a), '<b>foo</b>')
s._test_markup(pat.format(s.a))
pat = XMLFromMarkupPattern('[small ]foo[/small \t]')
s.assertEquals(pat.format(s.a), '<small >foo</small \t>')
s._test_markup(pat.format(s.a))
def test_span(s):
pat = XMLFromMarkupPattern(r'[span]foo[/span]')
s.assertEquals(pat.format(s.a), '<span>foo</span>')
s._test_markup(pat.format(s.a))
pat = XMLFromMarkupPattern(r'[span weight="bold"]foo[/span]')
s.assertEquals(pat.format(s.a), '<span weight="bold">foo</span>')
s._test_markup(pat.format(s.a))
def _preview_pattern(self, edit, label):
try:
text = XMLFromMarkupPattern(edit.text) % self._PREVIEW_ITEM
except:
text = _("Invalid pattern")
edit.apply.set_sensitive(False)
try:
Pango.parse_markup(text, -1, u"\u0000")
except GLib.GError:
text = _("Invalid pattern")
edit.apply.set_sensitive(False)
else:
edit.apply.set_sensitive(True)
label.set_markup(text)
def _on_set_pattern(self, button, edit, player):
self._pattern = edit.text.rstrip()
if self._pattern == SongInfo._pattern:
try:
os.unlink(self._pattern_filename)
except OSError:
pass
else:
try:
with open(self._pattern_filename, "wb") as h:
h.write(self._pattern.encode("utf-8") + "\n")
except EnvironmentError:
pass
self._compiled = XMLFromMarkupPattern(self._pattern)
self._update_info(player)
def validate_markup_pattern(text, alternative_markup=True, links=False):
"""Check whether a passed pattern results in a valid pango markup.
Args:
text (unicode): the pattern
alternative_markup (bool): if "[b]" gets mapped to "\\<b\\>"
links (bool): if link tags are allowed (for Gtk.Label only)
Raises:
ValueError: In case the pattern isn't valid
"""
assert isinstance(text, str)
f = AudioFile({"~filename": fsnative(u"dummy")})
try:
if alternative_markup:
pattern = XMLFromMarkupPattern(text)
else:
pattern = XMLFromPattern(text)
text = pattern % f
except PatternError as e:
return ValueError(e)
try:
Pango.parse_markup(text, -1, u"\u0000")
except GLib.GError as e:
if not links:
raise ValueError(e)
# Gtk.Label supports links on top of pango markup but doesn't
# provide a way to verify them. We can check if the markup
# was accepted by seeing if get_text() returns something.
l = Gtk.Label()
# add a character in case text is empty.
# this might print a warning to stderr.. no idea how to prevent that..
l.set_markup(text + " ")
if not l.get_text():
raise ValueError(e)
def test_convenience_invalid(s):
pat = XMLFromMarkupPattern(r'[b foo="1"]')
s.assertEquals(pat.format(s.a), '[b foo="1"]')
s._test_markup(pat.format(s.a))
def test_convenience_invalid(s):
pat = XMLFromMarkupPattern(r'[b foo="1"]')
s.assertEquals(pat.format(s.a), '[b foo="1"]')
s._test_markup(pat.format(s.a))
def test_link(s):
pat = XMLFromMarkupPattern(r'[a href=""]foo[/a]')
s.assertEquals(pat.format(s.a), '<a href="">foo</a>')
from quodlibet.util.path import mkdir, fsdecode, is_fsnative
from quodlibet.util.uri import URI
# Directory for playlist files
PLAYLISTS = os.path.join(quodlibet.get_user_dir(), "playlists")
assert is_fsnative(PLAYLISTS)
if not os.path.isdir(PLAYLISTS):
mkdir(PLAYLISTS)
_FOOTER = "<~tracks> (<~filesize> / <~length>)"
_PATTERN_TEXT = ("[b]<~name>[/b]\n"
"[small]<~tracks|%s|[i](%s)[/i]>[/small]" %
(_FOOTER, _("empty")))
"""The (currently) hard-coded pattern for formatting Playlist entries"""
PATTERN = XMLFromMarkupPattern(_PATTERN_TEXT)
class ConfirmRemovePlaylistDialog(qltk.Message):
def __init__(self, parent, playlist):
title = (_("Are you sure you want to delete the playlist '%s'?") %
escape(playlist.name))
description = (_("All information about the selected playlist "
"will be deleted and can not be restored."))
super(ConfirmRemovePlaylistDialog,
self).__init__(Gtk.MessageType.WARNING, parent, title,
description, Gtk.ButtonsType.NONE)
self.add_button(_("_Cancel"), Gtk.ResponseType.CANCEL)
self.add_icon_button(_("_Delete"), Icons.EDIT_DELETE,
def __refresh_pattern(cls):
cls.__pattern = XMLFromMarkupPattern(cls.__pattern_text)
def __refresh_pattern(cls, pattern_text):
cls.__pattern_text = pattern_text
cls.__pattern = XMLFromMarkupPattern(pattern_text)
def test_link(s):
pat = XMLFromMarkupPattern(r'[a href=""]foo[/a]')
s.assertEquals(pat.format(s.a), '<a href="">foo</a>')
