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 _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_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)