Recover files

mopidy_touchscreen/screens/__init__.py

@@ -0,0 +1,7 @@
+# flake8: noqa
+from library_screen import LibraryScreen
+from main_screen import MainScreen
+from menu_screen import MenuScreen
+from playlist_screen import PlaylistScreen
+from search_screen import SearchScreen
+from tracklist import Tracklist

mopidy_touchscreen/screens/base_screen.py

@@ -0,0 +1,13 @@
+class BaseScreen():
+
+    def __init__(self, size, base_size, manager, fonts):
+        self.size = size
+        self.base_size = base_size
+        self.manager = manager
+        self.fonts = fonts
+
+    def update(self, surface):
+        pass
+
+    def event(self, event):
+        pass

mopidy_touchscreen/screens/library_screen.py

@@ -0,0 +1,71 @@
+from base_screen import BaseScreen
+
+import mopidy.models
+
+from ..graphic_utils import ListView
+
+
+class LibraryScreen(BaseScreen):
+    def __init__(self, size, base_size, manager, fonts):
+        BaseScreen.__init__(self, size, base_size, manager, fonts)
+        self.list_view = ListView((0, 0), (
+            self.size[0], self.size[1] -
+            self.base_size), self.base_size, self.fonts['base'])
+        self.directory_list = []
+        self.current_directory = None
+        self.library = None
+        self.library_strings = None
+        self.browse_uri(None)
+
+    def go_inside_directory(self, uri):
+        self.directory_list.append(self.current_directory)
+        self.current_directory = uri
+        self.browse_uri(uri)
+
+    def browse_uri(self, uri):
+        self.library_strings = []
+        if uri is not None:
+            self.library_strings.append("../")
+        self.library = self.manager.core.library.browse(uri).get()
+        for lib in self.library:
+            self.library_strings.append(lib.name)
+        self.list_view.set_list(self.library_strings)
+
+    def go_up_directory(self):
+        if len(self.directory_list):
+            directory = self.directory_list.pop()
+            self.current_directory = directory
+            self.browse_uri(directory)
+
+    def update(self, screen):
+        self.list_view.render(screen)
+
+    def touch_event(self, touch_event):
+        clicked = self.list_view.touch_event(touch_event)
+        if clicked is not None:
+            if self.current_directory is not None:
+                if clicked == 0:
+                    self.go_up_directory()
+                else:
+                    if self.library[clicked - 1].type\
+                            == mopidy.models.Ref.TRACK:
+                        self.play_uri(clicked-1)
+                    else:
+                        self.go_inside_directory(
+                            self.library[clicked - 1].uri)
+            else:
+                self.go_inside_directory(self.library[clicked].uri)
+
+    def play_uri(self, track_pos):
+        self.manager.core.tracklist.clear()
+        tracks = []
+        for item in self.library:
+            if item.type == mopidy.models.Ref.TRACK:
+                tracks.append(self.manager.core.library.lookup(
+                    item.uri).get()[0])
+            else:
+                track_pos -= 1
+        self.manager.core.tracklist.add(tracks)
+        self.manager.core.playback.play(
+            tl_track=self.manager.core.tracklist.tl_tracks.get()
+            [track_pos])

mopidy_touchscreen/screens/main_screen.py

@@ -0,0 +1,443 @@
+import hashlib
+import json
+import logging
+import os
+import time
+import urllib
+import urllib2
+from threading import Thread
+
+
+from base_screen import BaseScreen
+
+import mopidy.core
+
+import pygame
+
+from ..graphic_utils import Progressbar, \
+    ScreenObjectsManager, TouchAndTextItem
+from ..input import InputManager
+
+
+logger = logging.getLogger(__name__)
+
+
+class MainScreen(BaseScreen):
+    def __init__(self, size, base_size, manager, fonts, cache, core,
+                 background):
+        BaseScreen.__init__(self, size, base_size, manager, fonts)
+        self.core = core
+        self.track = None
+        self.cache = cache
+        self.image = None
+        self.artists = None
+        self.background = background
+        self.track_duration = "00:00"
+        self.touch_text_manager = ScreenObjectsManager()
+        current_track = self.core.playback.current_track.get()
+        if current_track is None:
+            self.track_playback_ended(None, None)
+        else:
+            self.track_started(current_track)
+
+        # Top bar
+        self.top_bar = pygame.Surface((self.size[0], self.base_size),
+                                      pygame.SRCALPHA)
+        self.top_bar.fill((0, 0, 0, 128))
+
+        # Play/pause
+        button = TouchAndTextItem(self.fonts['icon'], u"\ue615 ",
+                                  (0, 0), None)
+        self.touch_text_manager.set_touch_object("pause_play", button)
+        x = button.get_right_pos()
+
+        # Random
+        button = TouchAndTextItem(self.fonts['icon'], u"\ue629 ",
+                                  (x, 0), None)
+        self.touch_text_manager.set_touch_object("random", button)
+        x = button.get_right_pos()
+
+        # Repeat
+        button = TouchAndTextItem(self.fonts['icon'], u"\ue626",
+                                  (x, 0), None)
+        self.touch_text_manager.set_touch_object("repeat", button)
+        x = button.get_right_pos()
+
+        # Single
+        button = TouchAndTextItem(self.fonts['base'], " 1 ", (x, 0),
+                                  None)
+        self.touch_text_manager.set_touch_object("single", button)
+        x = button.get_right_pos()
+
+        # Internet
+        button = TouchAndTextItem(self.fonts['icon'], u"\ue602 ",
+                                  (x, 0), None)
+        self.touch_text_manager.set_touch_object("internet", button)
+        x = button.get_right_pos()
+
+        # Mute
+        button = TouchAndTextItem(self.fonts['icon'], u"\ue61f ",
+                                  (x, 0), None)
+        self.touch_text_manager.set_touch_object("mute", button)
+        x = button.get_right_pos()
+
+        # Volume
+        progress = Progressbar(self.fonts['base'], "100", (x, 0),
+                               (self.size[0] - x, self.base_size),
+                               100, True)
+        self.touch_text_manager.set_touch_object("volume", progress)
+        progress.set_value(self.core.playback.volume.get())
+
+    def update(self, screen):
+        screen.blit(self.top_bar, (0, 0))
+        if self.track is not None:
+            self.touch_text_manager.get_touch_object(
+                "time_progress").set_value(
+                self.core.playback.time_position.get() / 1000)
+            self.touch_text_manager.get_touch_object(
+                "time_progress").set_text(
+                time.strftime('%M:%S', time.gmtime(
+                    self.core.playback.time_position.get() / 1000)) +
+                "/" + self.track_duration)
+            if self.image is not None:
+                screen.blit(self.image, (
+                    self.base_size / 2, self.base_size +
+                    self.base_size / 2))
+        self.touch_text_manager.render(screen)
+        return screen
+
+    def track_started(self, track):
+        self.image = None
+        x = self.base_size * 5
+        width = self.size[0] - self.base_size / 2 - x
+
+        self.track_duration = time.strftime('%M:%S', time.gmtime(
+            track.length / 1000))
+
+        # Load all artists
+        self.artists = []
+        for artist in track.artists:
+            self.artists.append(artist)
+
+        # Track name
+        label = TouchAndTextItem(self.fonts['base'],
+                                 MainScreen.get_track_name(track),
+                                 (x, self.base_size * 2), (width, -1))
+        self.touch_text_manager.set_touch_object("track_name", label)
+
+        # Album name
+        label = TouchAndTextItem(self.fonts['base'],
+                                 MainScreen.get_track_album_name
+                                 (track), (x, self.base_size * 3),
+                                 (width, -1))
+        self.touch_text_manager.set_touch_object("album_name", label)
+
+        # Artist
+        label = TouchAndTextItem(self.fonts['base'],
+                                 self.get_artist_string(),
+                                 (x, self.base_size * 4),
+                                 (width, -1))
+        self.touch_text_manager.set_touch_object("artist_name", label)
+
+        # Previous track button
+        button = TouchAndTextItem(self.fonts['icon'], u"\ue61c",
+                                  (0, self.base_size * 6), None)
+        self.touch_text_manager.set_touch_object("previous", button)
+        size_1 = button.get_right_pos()
+
+        size_2 = self.fonts['icon'].size(u"\ue61d")[0]
+        button = TouchAndTextItem(self.fonts['icon'], u"\ue61d",
+                                  (self.size[0] - size_2,
+                                   self.base_size * 6),
+                                  None)
+        self.touch_text_manager.set_touch_object("next", button)
+
+        # Progress
+        progress = Progressbar(self.fonts['base'],
+                               time.strftime('%M:%S', time.gmtime(
+                                   0)) + "/" + time.strftime(
+                                   '%M:%S', time.gmtime(0)),
+                               (size_1, self.base_size * 6),
+                               (
+                                   self.size[0] - size_1 - size_2,
+                                   self.base_size),
+                               track.length / 1000, False)
+        self.touch_text_manager.set_touch_object("time_progress",
+                                                 progress)
+
+        self.track = track
+        if not self.is_image_in_cache():
+            thread = Thread(target=self.download_image(0))
+            thread.start()
+        else:
+            self.load_image()
+
+    def get_artist_string(self):
+        artists_string = ''
+        for artist in self.artists:
+            artists_string += artist.name + ', '
+        if len(artists_string) > 2:
+            artists_string = artists_string[:-2]
+        elif len(artists_string) == 0:
+            artists_string = "Unknow Artist"
+        return artists_string
+
+    def get_image_file_name(self):
+        name = MainScreen.get_track_album_name(
+            self.track) + '-' + self.get_artist_string()
+        md5name = hashlib.md5(name.encode('utf-8')).hexdigest()
+        return md5name
+
+    def get_cover_folder(self):
+        if not os.path.isdir(self.cache + "/covers"):
+            os.makedirs(self.cache + "/covers")
+        return self.cache + "/covers/"
+
+    def is_image_in_cache(self):
+        self.get_cover_folder()
+        return os.path.isfile(
+            self.get_cover_folder() + self.get_image_file_name())
+
+    def download_image(self, artist_index):
+        if artist_index < len(self.artists):
+            try:
+                safe_artist = urllib.quote_plus(
+                    self.artists[artist_index].name)
+                safe_album = urllib.quote_plus(
+                    MainScreen.get_track_album_name(self.track))
+                url = "http://ws.audioscrobbler.com/2.0/?"
+                params = "method=album.getinfo&" + \
+                         "api_key=59a04c6a73fb99d6e8996e01db306829&" \
+                         + "artist=" \
+                         + safe_artist + "&album=" + safe_album + \
+                         "&format=json"
+                response = urllib2.urlopen(url + params)
+                data = json.load(response)
+                image = data['album']['image'][-1]['#text']
+                urllib.urlretrieve(image,
+                                   self.get_cover_folder() +
+                                   self.get_image_file_name())
+                self.load_image()
+            except:
+                self.download_image(artist_index + 1)
+        else:
+
+            logger.info("Cover could not be downloaded")
+
+            # There is no cover
+            # so it will use all the screen size for the text
+            width = self.size[0] - self.base_size
+
+            current = TouchAndTextItem(self.fonts['base'],
+                                       MainScreen.get_track_name
+                                       (self.track),
+                                       (self.base_size / 2,
+                                        self.base_size * 2),
+                                       (width, -1))
+            self.touch_text_manager.set_touch_object("track_name",
+                                                     current)
+
+            current = TouchAndTextItem(self.fonts['base'],
+                                       MainScreen.get_track_album_name
+                                       (self.track),
+                                       (self.base_size / 2,
+                                        self.base_size * 3),
+                                       (width, -1))
+            self.touch_text_manager.set_touch_object("album_name",
+                                                     current)
+
+            current = TouchAndTextItem(self.fonts['base'],
+                                       self.get_artist_string(),
+                                       (self.base_size / 2,
+                                        self.base_size * 4),
+                                       (width, -1))
+            self.touch_text_manager.set_touch_object("artist_name",
+                                                     current)
+
+    def track_playback_ended(self, tl_track, time_position):
+        self.background.set_target_color(None, None)
+        self.image = None
+        self.track_duration = "00:00"
+
+        width = self.size[0] - self.base_size
+
+        current = TouchAndTextItem(self.fonts['base'], "",
+                                   (self.base_size / 2,
+                                    self.base_size * 2),
+                                   (width, -1))
+        self.touch_text_manager.set_touch_object("track_name",
+                                                 current)
+
+        current = TouchAndTextItem(self.fonts['base'], "",
+                                   (self.base_size / 2,
+                                    self.base_size * 3),
+                                   (width, -1))
+        self.touch_text_manager.set_touch_object("album_name",
+                                                 current)
+
+        current = TouchAndTextItem(self.fonts['base'], "",
+                                   (self.base_size / 2,
+                                    self.base_size * 4),
+                                   (width, -1))
+        self.touch_text_manager.set_touch_object("artist_name",
+                                                 current)
+
+    def load_image(self):
+        size = self.base_size * 4
+        image_original = pygame.image.load(
+            self.get_cover_folder() +
+            self.get_image_file_name())
+        image = pygame.transform.scale(image_original, (size, size))
+        image = image.convert()
+        self.background.set_target_color(pygame.transform.average_color(image),
+                                         image_original)
+        self.image = image
+
+    def touch_event(self, event):
+        if event.type == InputManager.click:
+            objects = \
+                self.touch_text_manager.get_touch_objects_in_pos(
+                    event.current_pos)
+            if objects is not None:
+                self.click_on_objects(objects, event)
+
+        elif event.type == InputManager.swipe:
+            if event.direction == InputManager.left:
+                self.core.playback.next()
+            elif event.direction == InputManager.right:
+                self.core.playback.previous()
+            elif event.direction == InputManager.up:
+                volume = self.core.playback.volume.get() + 10
+                if volume > 100:
+                    volume = 100
+                self.core.playback.volume = volume
+                self.manager.volume_changed(volume)
+            elif event.direction == InputManager.down:
+                volume = self.core.playback.volume.get() - 10
+                if volume < 0:
+                    volume = 0
+                self.core.playback.volume = volume
+                self.manager.volume_changed(volume)
+
+    def click_on_objects(self, objects, event):
+        if objects is not None:
+            for key in objects:
+                if key == "time_progress":
+                    value = self.touch_text_manager.get_touch_object(
+                        key).get_pos_value(
+                        event.current_pos) * 1000
+                    self.core.playback.seek(value)
+
+                elif key == "previous":
+                    self.core.playback.previous()
+                elif key == "next":
+                    self.core.playback.next()
+                elif key == "volume":
+                    self.change_volume(event)
+                elif key == "pause_play":
+                    if self.core.playback.state.get() == \
+                            mopidy.core.PlaybackState.PLAYING:
+                        self.core.playback.pause()
+                    else:
+                        self.core.playback.play()
+                elif key == "mute":
+                    mute = not self.core.playback.mute.get()
+                    self.core.playback.set_mute(mute)
+                    self.mute_changed(mute)
+                elif key == "random":
+                    random = not self.core.tracklist.random.get()
+                    self.core.tracklist.set_random(random)
+                    self.options_changed()
+                elif key == "repeat":
+                    self.core.tracklist.set_repeat(
+                        not self.core.tracklist.repeat.get())
+                elif key == "single":
+                    self.core.tracklist.set_single(
+                        not self.core.tracklist.single.get())
+                elif key == "internet":
+                    self.manager.check_connection()
+                elif key == "track_name":
+                    self.manager.search(self.track.name, 0)
+                elif key == "album_name":
+                    self.manager.search(self.track.album.name, 1)
+                elif key == "artist_name":
+                    self.manager.search(self.get_artist_string(), 2)
+
+    def change_volume(self, event):
+        manager = self.touch_text_manager
+        volume = manager.get_touch_object("volume")
+        pos = event.current_pos
+        value = volume.get_pos_value(pos)
+        self.core.playback.volume = value
+        self.volume_changed(value)
+
+    def volume_changed(self, volume):
+        if not self.core.playback.mute.get():
+            if volume > 80:
+                self.touch_text_manager.get_touch_object(
+                    "mute").set_text(
+                    u"\ue61f", False)
+            elif volume > 50:
+                self.touch_text_manager.get_touch_object(
+                    "mute").set_text(
+                    u"\ue620", False)
+            elif volume > 20:
+                self.touch_text_manager.get_touch_object(
+                    "mute").set_text(
+                    u"\ue621", False)
+            else:
+                self.touch_text_manager.get_touch_object(
+                    "mute").set_text(
+                    u"\ue622", False)
+        self.touch_text_manager.get_touch_object("volume").set_value(
+            volume)
+
+    def options_changed(self):
+        self.touch_text_manager.get_touch_object("random").set_active(
+            self.core.tracklist.random.get())
+        self.touch_text_manager.get_touch_object("repeat").set_active(
+            self.core.tracklist.repeat.get())
+        self.touch_text_manager.get_touch_object("single").set_active(
+            self.core.tracklist.single.get())
+
+    def mute_changed(self, mute):
+        self.touch_text_manager.get_touch_object("mute").set_active(
+            not mute)
+        if mute:
+            self.touch_text_manager.get_touch_object("mute").set_text(
+                u"\ue623", False)
+        else:
+            self.volume_changed(self.core.playback.volume.get())
+
+    def playback_state_changed(self, old_state, new_state):
+        if new_state == mopidy.core.PlaybackState.PLAYING:
+            self.touch_text_manager.get_touch_object(
+                "pause_play").set_text(u"\ue616", False)
+        else:
+            self.touch_text_manager.get_touch_object(
+                "pause_play").set_text(u"\ue615", False)
+
+    def set_connection(self, connection, loading):
+        internet = self.touch_text_manager.get_touch_object(
+            "internet")
+        if loading:
+            internet.set_text(u"\ue627", None)
+            internet.set_active(False)
+        else:
+            internet.set_text(u"\ue602", None)
+            internet.set_active(connection)
+
+    @staticmethod
+    def get_track_name(track):
+        if track.name is None:
+            return track.uri
+        else:
+            return track.name
+
+    @staticmethod
+    def get_track_album_name(track):
+        if track.album is not None and track.album.name is not None\
+                and len(track.album.name) > 0:
+            return track.album.name
+        else:
+            return "Unknow Album"

mopidy_touchscreen/screens/menu_screen.py

@@ -0,0 +1,54 @@
+import os
+import socket
+
+from base_screen import BaseScreen
+
+import mopidy
+
+from ..graphic_utils import ListView
+
+
+class MenuScreen(BaseScreen):
+    def __init__(self, size, base_size, manager, fonts):
+        BaseScreen.__init__(self, size, base_size, manager, fonts)
+        self.ip = None
+        self.list = ListView((0, 0), size, base_size, fonts['base'])
+
+        self.list_items = ["Exit Mopidy", "Shutdown", "Restart", "IP: "]
+
+        self.list.set_list(self.list_items)
+
+    def update(self, screen):
+        self.list.render(screen)
+
+    def touch_event(self, event):
+        clicked = self.list.touch_event(event)
+        if clicked is not None:
+            if clicked == 0:
+                mopidy.utils.process.exit_process()
+            elif clicked == 1:
+                if os.system("gksu -- shutdown now -h") != 0:
+                    os.system("sudo shutdown now -h")
+            elif clicked == 2:
+                if os.system("gksu -- shutdown -r now") != 0:
+                    os.system("sudo shutdown -r now")
+            elif clicked == 3:
+                self.check_connection()
+
+    # Will check internet connection
+    def check_connection(self):
+        try:
+            self.manager.set_connection(False, True)
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            s.connect(("8.8.8.8", 80))
+            self.ip = s.getsockname()[0]
+            s.close()
+            self.list_items[3] = "IP: " + self.ip
+            self.list.set_list(self.list_items)
+            self.manager.set_connection(True, False)
+        except socket.error:
+            s.close()
+            self.ip = None
+            self.list_items[2] = "IP: No internet"
+            self.list.set_list(self.list_items)
+            self.manager.set_connection(False, False)

mopidy_touchscreen/screens/playlist_screen.py

@@ -0,0 +1,56 @@
+from base_screen import BaseScreen
+
+from ..graphic_utils import ListView
+
+
+class PlaylistScreen(BaseScreen):
+    def __init__(self, size, base_size, manager, fonts):
+        BaseScreen.__init__(self, size, base_size, manager, fonts)
+        self.list_view = ListView((0, 0), (
+            self.size[0], self.size[1] -
+            self.base_size), self.base_size,
+            self.fonts['base'])
+        self.playlists_strings = []
+        self.playlists = []
+        self.playlists_loaded()
+        self.selected_playlist = None
+        self.playlist_tracks = []
+        self.playlist_tracks_strings = []
+
+    def update(self, screen):
+        self.list_view.render(screen)
+
+    def playlists_loaded(self):
+        self.selected_playlist = None
+        self.playlists_strings = []
+        self.playlists = []
+        for playlist in self.manager.core.playlists.playlists.get():
+            self.playlists.append(playlist)
+            self.playlists_strings.append(playlist.name)
+        self.list_view.set_list(self.playlists_strings)
+
+    def playlist_selected(self, playlist):
+        self.selected_playlist = playlist
+        self.playlist_tracks = playlist.tracks
+        self.playlist_tracks_strings = ["../"]
+        for track in self.playlist_tracks:
+            self.playlist_tracks_strings.append(track.name)
+        self.list_view.set_list(self.playlist_tracks_strings)
+
+    def touch_event(self, touch_event):
+        clicked = self.list_view.touch_event(touch_event)
+        if clicked is not None:
+            if self.selected_playlist is None:
+                self.playlist_selected(self.playlists[clicked])
+            else:
+                if clicked == 0:
+                    self.selected_playlist = None
+                    self.list_view.set_list(self.playlists_strings)
+                else:
+                    self.manager.core.tracklist.clear()
+                    self.manager.core.tracklist.add(
+                        self.playlist_tracks)
+                    self.manager.core.playback.play(
+                        tl_track=self.manager.core.
+                        tracklist.tl_tracks.get()
+                        [clicked-1])

mopidy_touchscreen/screens/search_screen.py

@@ -0,0 +1,135 @@
+from base_screen import BaseScreen
+
+import pygame
+
+from ..graphic_utils import ListView,\
+    ScreenObjectsManager, TextItem, TouchAndTextItem
+
+from ..input import InputManager
+
+mode_track_name = 0
+mode_album_name = 1
+mode_artist_name = 2
+
+
+class SearchScreen(BaseScreen):
+    def __init__(self, size, base_size, manager, fonts):
+        BaseScreen.__init__(self, size, base_size, manager, fonts)
+        self.list_view = ListView((0, self.base_size*2), (
+            self.size[0], self.size[1] -
+            3*self.base_size), self.base_size, manager.fonts['base'])
+        self.results_strings = []
+        self.results = []
+        self.screen_objects = ScreenObjectsManager()
+        self.query = ""
+
+        # Query text
+        text = TextItem(self.fonts['base'], self.query, (0, 0),
+                        (self.size[0], self.base_size), center=True)
+        self.screen_objects.set_object("query", text)
+
+        # Mode buttons
+        button_size = (self.size[0] / 3, self.base_size)
+        self.mode_objects_keys = ["mode_track", "mode_album",
+                                  "mode_artist"]
+
+        # Track button
+        button = TouchAndTextItem(self.fonts['base'], "Track",
+                                  (0, self.base_size),
+                                  button_size, center=True)
+        self.screen_objects.set_touch_object(
+            self.mode_objects_keys[0], button)
+
+        # Album button
+        button = TouchAndTextItem(self.fonts['base'], "Album",
+                                  (button_size[0], self.base_size),
+                                  button_size, center=True)
+        self.screen_objects.set_touch_object(
+            self.mode_objects_keys[1], button)
+
+        # Artist button
+        button = TouchAndTextItem(self.fonts['base'], "Artist",
+                                  (button_size[0]*2, self.base_size),
+                                  button_size, center=True)
+        self.screen_objects.set_touch_object(
+            self.mode_objects_keys[2], button)
+
+        # Top Bar
+        self.top_bar = pygame.Surface(
+            (self.size[0], self.base_size * 2),
+            pygame.SRCALPHA)
+        self.top_bar.fill((0, 0, 0, 128))
+
+        self.mode = -100
+        self.set_mode(mode=mode_track_name)
+        self.set_query("")
+
+    def update(self, screen):
+        screen.blit(self.top_bar, (0, 0))
+        self.screen_objects.render(screen)
+        self.list_view.render(screen)
+
+    def set_mode(self, mode=mode_track_name):
+        if mode is not self.mode:
+            self.mode = mode
+            for key in self.mode_objects_keys:
+                self.screen_objects.get_touch_object(key).\
+                    set_active(False)
+            self.screen_objects.get_touch_object(
+                self.mode_objects_keys[self.mode]).set_active(True)
+
+    def set_query(self, query=""):
+        self.query = query
+        self.screen_objects.get_object("query").set_text(
+            self.query, False)
+
+    def search(self, query=None, mode=None):
+        if query is not None:
+            self.set_query(query)
+        if mode is not None:
+            self.set_mode(mode)
+        if self.mode == mode_track_name:
+            search_query = {'any': [self.query]}
+        elif self.mode == mode_album_name:
+            search_query = {'album': [self.query]}
+        else:
+            search_query = {'artist': [self.query]}
+        if len(self.query) > 0:
+            current_results = self.manager.core.library.search(
+                search_query).get()
+            self.results = []
+            self.results_strings = []
+            for backend in current_results:
+                if mode == mode_track_name:
+                    iterable = backend.tracks
+                elif mode == mode_album_name:
+                    iterable = backend.albums
+                else:
+                    iterable = backend.artists
+
+                for result in iterable:
+                    self.results.append(result)
+                    self.results_strings.append(result.name)
+            self.list_view.set_list(self.results_strings)
+
+    def touch_event(self, touch_event):
+        if touch_event.type == InputManager.click:
+            clicked = self.list_view.touch_event(touch_event)
+            if clicked is not None:
+                self.manager.core.tracklist.clear()
+                self.manager.core.tracklist.add(
+                    uri=self.results[clicked].uri)
+                self.manager.core.playback.play()
+            else:
+                clicked = self.screen_objects.get_touch_objects_in_pos(
+                    touch_event.down_pos)
+                if len(clicked) > 0:
+                    clicked = clicked[0]
+                    if clicked == self.mode_objects_keys[0]:
+                        self.search(mode=0)
+                    if clicked == self.mode_objects_keys[1]:
+                        self.search(mode=1)
+                    if clicked == self.mode_objects_keys[2]:
+                        self.search(mode=2)
+        else:
+            self.list_view.touch_event(touch_event)

mopidy_touchscreen/screens/tracklist.py

@@ -0,0 +1,43 @@
+from base_screen import BaseScreen
+
+from .main_screen import MainScreen
+from ..graphic_utils import ListView
+
+
+class Tracklist(BaseScreen):
+    def __init__(self, size, base_size, manager, fonts):
+        BaseScreen.__init__(self, size, base_size, manager, fonts)
+        self.size = size
+        self.base_size = base_size
+        self.manager = manager
+        self.list_view = ListView((0, 0), (
+            self.size[0], self.size[1] -
+            self.base_size), self.base_size, self.fonts['base'])
+        self.tracks = []
+        self.tracks_strings = []
+        self.update_list()
+        self.track_started(
+            self.manager.core.playback.current_tl_track.get())
+
+    def update(self, screen):
+        self.list_view.render(screen)
+
+    def tracklist_changed(self):
+        self.update_list()
+
+    def update_list(self):
+        self.tracks = self.manager.core.tracklist.tl_tracks.get()
+        self.tracks_strings = []
+        for tl_track in self.tracks:
+            self.tracks_strings.append(
+                MainScreen.get_track_name(tl_track.track))
+        self.list_view.set_list(self.tracks_strings)
+
+    def touch_event(self, touch_event):
+        pos = self.list_view.touch_event(touch_event)
+        if pos is not None:
+            self.manager.core.playback.play(self.tracks[pos])
+
+    def track_started(self, track):
+        self.list_view.set_active(
+            [self.manager.core.tracklist.index(track).get()])