def Query(self, text):
     if text is not None:
         query = Query(text, star=SongList.star)
         if query.is_parsable:
             return [self.__dict(s) for s in itervalues(self.library)
                     if query.search(s)]
     return None

    def GetSubsearchResultSet(self, previous_results, terms):
        query = Query("")
        for term in terms:
            query &= Query(term)

        songs = get_songs_for_ids(app.library, previous_results)
        ids = [get_song_id(s) for s in songs if query.search(s)]
        return ids

    def activate(self, widget=None, resort=True):
        songs = self._get_playlist_songs()

        text = self._get_text()
        # TODO: remove static dependency on Query
        if Query.is_parsable(text):
            self._query = Query(text, SongList.star)
            songs = self._query.filter(songs)
        GLib.idle_add(self.songs_selected, songs, resort)

    def test_extension(self):
        self.failUnless(Query.is_valid("@(name)"))
        self.failUnless(Query.is_valid("@(name: extension body)"))
        self.failUnless(Query.is_valid("@(name: body (with (nested) parens))"))
        self.failUnless(Query.is_valid(r"@(name: body \\ with \) escapes)"))

        self.failIf(Query.is_valid("@()"))
        self.failIf(Query.is_valid(r"@(invalid %name!\\)"))
        self.failIf(Query.is_valid("@(name: mismatched ( parenthesis)"))
        self.failIf(Query.is_valid(r"@(\()"))
        self.failIf(Query.is_valid("@(name:unclosed body"))
        self.failIf(Query.is_valid("@ )"))

def QueryValidator(string):
    """Returns True/False for a query, None for a text only query"""

    type_ = Query.get_type(string)
    if type_ == QueryType.VALID:
        # in case of an empty but valid query we say it's "text"
        if Query.match_all(string):
            return None
        return True
    elif type_ == QueryType.INVALID:
        return False
    return None

    def restore(self):
        text = config.get("browsers", "query_text").decode("utf-8")
        entry = self.__search
        entry.set_text(text)

        # update_filter expects a parsable query
        if Query.is_parsable(text):
            self.__update_filter(entry, text, scroll_up=False, restore=True)

        keys = config.get("browsers", "albums").split("\n")

        # FIXME: If albums is "" then it could be either all albums or
        # no albums. If it's "" and some other stuff, assume no albums,
        # otherwise all albums.
        self.__inhibit()
        if keys == [""]:
            self.view.set_cursor((0,))
        else:

            def select_fun(row):
                album = row[0]
                if not album:  # all
                    return False
                return album.str_key in keys
            self.view.select_by_func(select_fun)
        self.__uninhibit()

 def _get_songs(self):
     try:
         self._query = Query(self._text, star=SongList.star)
     except Query.error:
         pass
     else:
         return self._query.filter(self._library)

 def filter_text(self, text):
     self.__search.set_text(text)
     if Query.is_parsable(text):
         self.__update_filter(self.__search, text)
         self.__inhibit()
         self.view.set_cursor((0,))
         self.__uninhibit()
         self.activate()

    def __update_filter(self, entry, text):
        self.__filter = None
        if not Query.match_all(text):
            tags = self.__model.tags + ["album"]
            self.__filter = Query(text, star=tags).search
        self.__bg_filter = background_filter()

        self.view.get_model().refilter()

    def test_numcmp(self):
        self.failUnless(Query.is_valid("#(t < 3)"))
        self.failUnless(Query.is_valid("#(t <= 3)"))
        self.failUnless(Query.is_valid("#(t > 3)"))
        self.failUnless(Query.is_valid("#(t >= 3)"))
        self.failUnless(Query.is_valid("#(t = 3)"))
        self.failUnless(Query.is_valid("#(t != 3)"))

        self.failIf(Query.is_valid("#(t !> 3)"))
        self.failIf(Query.is_valid("#(t >> 3)"))

 def test_not(self):
     self.failUnless(Query.is_valid('t = !/a/'))
     self.failUnless(Query.is_valid('t = !!/a/'))
     self.failUnless(Query.is_valid('!t = "a"'))
     self.failUnless(Query.is_valid('!!t = "a"'))
     self.failUnless(Query.is_valid('t = !|(/a/, !"b")'))
     self.failUnless(Query.is_valid('t = !!|(/a/, !"b")'))
     self.failUnless(Query.is_valid('!|(t = /a/)'))

 def activate(self):
     text = self._get_text()
     if Query.is_parsable(text):
         star = dict.fromkeys(SongList.star)
         star.update(self.__star)
         self._filter = Query(text, star.keys()).search
         songs = filter(self._filter, self._library)
         bg = background_filter()
         if bg:
             songs = filter(bg, songs)
         self._panes[0].fill(songs)

 def test_tag(self):
     self.failUnless(Query.is_valid('t = tag'))
     self.failUnless(Query.is_valid('t = !tag'))
     self.failUnless(Query.is_valid('t = |(tag, bar)'))
     self.failUnless(Query.is_valid('t = a"tag"'))
     self.failIf(Query.is_valid('t = a, tag'))
     self.failUnless(Query.is_valid('tag with spaces = tag'))

 def test_re(self):
     self.failUnless(Query.is_valid('t = /an re/'))
     self.failUnless(Query.is_valid('t = /an re/c'))
     self.failUnless(Query.is_valid('t = /an\\/re/'))
     self.failIf(Query.is_valid('t = /an/re/'))
     self.failUnless(Query.is_valid('t = /aaa/lsic'))
     self.failIf(Query.is_valid('t = /aaa/icslx'))

    def __save_search(self, entry, *args):
        # only save the query on focus-out if eager_search is turned on
        if args and not config.getboolean('settings', 'eager_search'):
            return

        text = self.get_text().strip()
        if text and Query.is_parsable(text):
            # Adding the active text to the model triggers a changed signal
            # (get_active is no longer -1), so inhibit
            self.__inhibit()
            self.__combo.prepend_text(text)
            self.__combo.write()
            self.__uninhibit()

    def test_andor(self):
        self.failUnless(Query.is_valid('a = |(/a/, /b/)'))
        self.failUnless(Query.is_valid('a = |(/b/)'))
        self.failUnless(Query.is_valid('|(a = /b/, c = /d/)'))

        self.failUnless(Query.is_valid('a = &(/a/, /b/)'))
        self.failUnless(Query.is_valid('a = &(/b/)'))
        self.failUnless(Query.is_valid('&(a = /b/, c = /d/)'))

    def test_filter(self):
        q = Query("artist=piman")
        self.assertEqual(q.filter([self.s1, self.s2]), [self.s1])
        self.assertEqual(q.filter(iter([self.s1, self.s2])), [self.s1])

        q = Query("")
        self.assertEqual(q.filter([self.s1, self.s2]), [self.s1, self.s2])
        self.assertEqual(
            q.filter(iter([self.s1, self.s2])), [self.s1, self.s2])

    def restore(self):
        text = config.get("browsers", "query_text").decode("utf-8")
        self.__searchbar.set_text(text)
        if Query.is_parsable(text):
            self.__filter_changed(self.__searchbar, text, restore=True)

        keys = config.get("browsers", "radio").splitlines()

        def select_func(row):
            return row[self.TYPE] != self.TYPE_SEP and row[self.KEY] in keys

        self.__inhibit()
        view = self.view
        if not view.select_by_func(select_func):
            for row in view.get_model():
                if row[self.TYPE] == self.TYPE_FAV:
                    view.set_cursor(row.path)
                    break
        self.__uninhibit()

    def __update_filter(self, entry, text, scroll_up=True, restore=False):
        model = self.view.get_model()

        self.__filter = None
        if not Query.match_all(text):
            self.__filter = Query(text, star=["~people", "album"]).search
        self.__bg_filter = background_filter()

        self.__inhibit()

        # If we're hiding "All Albums", then there will always
        # be something to filter ­— probably there's a better
        # way to implement this

        if (not restore or self.__filter or self.__bg_filter) or (not
            config.getboolean("browsers", "covergrid_all", False)):
            model.refilter()

        self.__uninhibit()

    def __update_filter(self, entry, text, scroll_up=True, restore=False):
        model = self.view.get_model()

        self.__filter = None
        if not Query.match_all(text):
            self.__filter = Query(text, star=["~people", "album"]).search
        self.__bg_filter = background_filter()

        self.__inhibit()

        # We could be smart and try to scroll to a selected album
        # but that introduces lots of wild scrolling. Feel free to change it.
        # Without scrolling the TV tries to stay at the same position
        # (40% down) which makes no sense, so always go to the top.
        if scroll_up:
            self.view.scroll_to_point(0, 0)

        # Don't filter on restore if there is nothing to filter
        if not restore or self.__filter or self.__bg_filter:
            model.refilter()

        self.__uninhibit()