Search funtionality first preview (Bad icon)

Some buttons shown only on main screen

mopidy_touchscreen/library_screen.py

@@ -12,8 +12,8 @@ class LibraryScreen():
         self.size = size
         self.base_size = base_size
         self.manager = manager
-        self.list_view = ListView((0, self.base_size), (
-            self.size[0], self.size[1] - 2 * self.base_size),
+        self.list_view = ListView((0, 0), (
+            self.size[0], self.size[1] - self.base_size),
                                   self.base_size,
                                   manager.fonts['base'])
         self.directory_list = []

mopidy_touchscreen/main_screen.py

@@ -3,6 +3,7 @@ import json
 import logging
 import os
 import time
+import mopidy.core
 import urllib
 import urllib2
 from threading import Thread
@@ -35,8 +36,58 @@ class MainScreen():
             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, update_all):
+        screen.blit(self.top_bar, (0, 0))
         if self.track is not None:
             self.touch_text_manager.get_touch_object(
                 "time_progress").set_value(
@@ -45,8 +96,9 @@ class MainScreen():
                 "time_progress").set_text(
                 time.strftime('%M:%S', time.gmtime(
                     self.core.playback.time_position.get() / 1000)) + "/" + self.track_duration)
-            screen.blit(self.image, (
-            self.base_size / 2, self.base_size + self.base_size / 2))
+            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
 
@@ -64,24 +116,24 @@ class MainScreen():
             self.artists.append(artist)
 
         # Track name
-        label = TextItem(self.fonts['base'],
+        label = TouchAndTextItem(self.fonts['base'],
                          MainScreen.get_track_name(track),
                          (x, self.base_size * 2),
-                         (width, self.size[1]))
-        self.touch_text_manager.set_object("track_name", label)
+                         (width, -1))
+        self.touch_text_manager.set_touch_object("track_name", label)
 
         # Album name
-        label = TextItem(self.fonts['base'],
+        label = TouchAndTextItem(self.fonts['base'],
                          MainScreen.get_track_album_name(track),
                          (x, self.base_size * 3),
-                         (width, self.size[1]))
-        self.touch_text_manager.set_object("album_name", label)
+                         (width, -1))
+        self.touch_text_manager.set_touch_object("album_name", label)
 
         # Artist
-        label = TextItem(self.fonts['base'], self.get_artist_string(),
+        label = TouchAndTextItem(self.fonts['base'], self.get_artist_string(),
                          (x, self.base_size * 4),
-                         (width, self.size[1]))
-        self.touch_text_manager.set_object("artist_name", label)
+                         (width, -1))
+        self.touch_text_manager.set_touch_object("artist_name", label)
 
         # Previous track button
         button = TouchAndTextItem(self.fonts['icon'], u"\ue61c",
@@ -117,7 +169,6 @@ class MainScreen():
         else:
             self.load_image()
 
-
     def get_artist_string(self):
         artists_string = ''
         for artist in self.artists:
@@ -173,27 +224,27 @@ class MainScreen():
             # There is no cover so it will use all the screen size for the text
             width = self.size[0] - self.base_size
 
-            current = TextItem(self.fonts['base'],
+            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_object("track_name", current)
+            self.touch_text_manager.set_touch_object("track_name", current)
 
-            current = TextItem(self.fonts['base'],
+            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_object("album_name", current)
+            self.touch_text_manager.set_touch_object("album_name", current)
 
-            current = TextItem(self.fonts['base'],
+            current = TouchAndTextItem(self.fonts['base'],
                                self.get_artist_string(),
                                (self.base_size / 2,
                                 self.base_size * 4),
                                (width, -1))
-            self.touch_text_manager.set_object("artist_name", current)
+            self.touch_text_manager.set_touch_object("artist_name", current)
 
     def track_playback_ended(self, tl_track, time_position):
         if self.image is not None:
@@ -205,24 +256,22 @@ class MainScreen():
 
         self.track_duration = "00:00"
 
-
-        # There is no cover so it will use all the screen size for the text
         width = self.size[0] - self.base_size
 
-        current = TextItem(self.fonts['base'], "Stopped",
+        current = TouchAndTextItem(self.fonts['base'], "",
                            (self.base_size / 2, self.base_size * 2),
                            (width, -1))
-        self.touch_text_manager.set_object("track_name", current)
+        self.touch_text_manager.set_touch_object("track_name", current)
 
-        current = TextItem(self.fonts['base'], "",
+        current = TouchAndTextItem(self.fonts['base'], "",
                            (self.base_size / 2, self.base_size * 3),
                            (width, -1))
-        self.touch_text_manager.set_object("album_name", current)
+        self.touch_text_manager.set_touch_object("album_name", current)
 
-        current = TextItem(self.fonts['base'], "",
+        current = TouchAndTextItem(self.fonts['base'], "",
                            (self.base_size / 2, self.base_size * 4),
                            (width, -1))
-        self.touch_text_manager.set_object("artist_name", current)
+        self.touch_text_manager.set_touch_object("artist_name", current)
 
     def load_image(self):
         size = self.base_size * 4
@@ -231,24 +280,14 @@ class MainScreen():
                 self.get_cover_folder() +
                 self.get_image_file_name()).convert(),
             (size, size))
-        self.image_now_loaded = True
 
     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:
-                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()
+                self.click_on_objects(objects, event)
+
         elif event.type == InputManager.swipe:
             if event.direction == InputManager.left:
                 self.core.playback.next()
@@ -268,6 +307,114 @@ class MainScreen():
                 self.manager.backend.tell(
                     {'action': 'volume', 'value': 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):

mopidy_touchscreen/menu_screen.py

@@ -17,42 +17,42 @@ class MenuScreen():
         # Exit mopidy button
         button = TouchAndTextItem(self.manager.fonts['icon'],
                                   u"\ue611",
-                                  (0, self.base_size), None)
+                                  (0, 0), None)
         self.screen_objects.set_touch_object("exit_icon", button)
         button = TouchAndTextItem(self.manager.fonts['base'],
                                   "Exit Mopidy",
                                   (button.get_right_pos(),
-                                   self.base_size),
+                                   0),
                                   None)
         self.screen_objects.set_touch_object("exit", button)
 
         # Shutdown button
         button = TouchAndTextItem(self.manager.fonts['icon'],
                                   u"\ue60b",
-                                  (0, self.base_size * 2), None)
+                                  (0, self.base_size * 1), None)
         self.screen_objects.set_touch_object("shutdown_icon", button)
         button = TouchAndTextItem(self.manager.fonts['base'],
                                   "Shutdown",
                                   (button.get_right_pos(),
-                                   self.base_size * 2),
+                                   self.base_size * 1),
                                   None)
         self.screen_objects.set_touch_object("shutdown", button)
 
         # Restart button
         button = TouchAndTextItem(self.manager.fonts['icon'],
                                   u"\ue609",
-                                  (0, self.base_size * 3), None)
+                                  (0, self.base_size * 2), None)
         self.screen_objects.set_touch_object("restart_icon", button)
         button = TouchAndTextItem(self.manager.fonts['base'],
                                   "Restart",
                                   (button.get_right_pos(),
-                                   self.base_size * 3),
+                                   self.base_size * 2),
                                   None)
         self.screen_objects.set_touch_object("restart", button)
 
         # IP addres
         button = TouchAndTextItem(self.manager.fonts['base'], "IP: ",
-                                  (0, self.base_size * 4), None)
+                                  (0, self.base_size * 3), None)
         self.screen_objects.set_touch_object("ip", button)
 
     def update(self, screen, update_all):

mopidy_touchscreen/playlist_screen.py

@@ -6,8 +6,8 @@ class PlaylistScreen():
         self.size = size
         self.base_size = base_size
         self.manager = manager
-        self.list_view = ListView((0, self.base_size), (
-            self.size[0], self.size[1] - 2 * self.base_size),
+        self.list_view = ListView((0, 0), (
+            self.size[0], self.size[1] - self.base_size),
                                   self.base_size,
                                   manager.fonts['base'])
         self.playlists_strings = []

mopidy_touchscreen/screen_manager.py

@@ -5,6 +5,7 @@ import mopidy.core
 import pygame
 from pkg_resources import Requirement, resource_filename
 
+from .search_screen import SearchScreen
 from .library_screen import LibraryScreen
 from .main_screen import MainScreen
 from .menu_screen import MenuScreen
@@ -17,6 +18,13 @@ from .tracklist import Tracklist
 
 logger = logging.getLogger(__name__)
 
+search_index = 0
+main_screen_index = 1
+tracklist_index = 2
+library_index = 3
+playlist_index = 4
+menu_index = 5
+
 
 class ScreenManager():
     def __init__(self, size, core, cache):
@@ -33,6 +41,7 @@ class ScreenManager():
         self.fonts['icon'] = pygame.font.Font(font, self.base_size)
         try:
             self.screens = [
+                SearchScreen(size, self.base_size, self),
                 MainScreen(size, self, cache, core, self.fonts),
                 Tracklist(size, self.base_size, self),
                 LibraryScreen(size, self.base_size, self),
@@ -48,90 +57,49 @@ class ScreenManager():
         self.dirty_area = []
         self.screen_changed = True
 
-        # 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.top_bar_objects.set_touch_object("pause_play", button)
-        x = button.get_right_pos()
-
-        # Random
-        button = TouchAndTextItem(self.fonts['icon'], u"\ue629 ",
-                                  (x, 0), None)
-        self.top_bar_objects.set_touch_object("random", button)
-        x = button.get_right_pos()
-
-        # Repeat
-        button = TouchAndTextItem(self.fonts['icon'], u"\ue626",
-                                  (x, 0), None)
-        self.top_bar_objects.set_touch_object("repeat", button)
-        x = button.get_right_pos()
-
-        # Single
-        button = TouchAndTextItem(self.fonts['base'], " 1 ", (x, 0),
-                                  None)
-        self.top_bar_objects.set_touch_object("single", button)
-        x = button.get_right_pos()
+        # Menu buttons
 
-        # Internet
-        button = TouchAndTextItem(self.fonts['icon'], u"\ue602 ",
-                                  (x, 0), None)
-        self.top_bar_objects.set_touch_object("internet", button)
-        x = button.get_right_pos()
+        button_size = (self.size[0] / 6, self.base_size)
 
-        # Mute
-        button = TouchAndTextItem(self.fonts['icon'], u"\ue61f ",
-                                  (x, 0), None)
-        self.top_bar_objects.set_touch_object("mute", button)
+         # Search button
+        button = TouchAndTextItem(self.fonts['icon'], u" \ue601",
+                                  (0, self.base_size * 7),
+                                  button_size)
+        self.down_bar_objects.set_touch_object("menu_0", 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.top_bar_objects.set_touch_object("volume", progress)
-        progress.set_value(self.core.playback.volume.get())
-
-        # Menu buttons
-
-        button_size = (self.size[0] / 5, self.base_size)
-
         # Main button
         button = TouchAndTextItem(self.fonts['icon'], u" \ue600",
-                                  (0, self.base_size * 7),
+                                  (x, self.base_size * 7),
                                   button_size)
-        self.down_bar_objects.set_touch_object("menu_0", button)
+        self.down_bar_objects.set_touch_object("menu_1", button)
         x = button.get_right_pos()
 
         # Tracklist button
         button = TouchAndTextItem(self.fonts['icon'], u" \ue60d",
                                   (x, self.base_size * 7),
                                   button_size)
-        self.down_bar_objects.set_touch_object("menu_1", button)
+        self.down_bar_objects.set_touch_object("menu_2", button)
         x = button.get_right_pos()
 
         # Library button
         button = TouchAndTextItem(self.fonts['icon'], u" \ue604",
                                   (x, self.base_size * 7),
                                   button_size)
-        self.down_bar_objects.set_touch_object("menu_2", button)
+        self.down_bar_objects.set_touch_object("menu_3", button)
         x = button.get_right_pos()
 
         # Playlist button
         button = TouchAndTextItem(self.fonts['icon'], u" \ue605",
                                   (x, self.base_size * 7),
                                   button_size)
-        self.down_bar_objects.set_touch_object("menu_3", button)
+        self.down_bar_objects.set_touch_object("menu_4", button)
         x = button.get_right_pos()
 
         # Menu button
         button = TouchAndTextItem(self.fonts['icon'], u" \ue60a",
                                   (x, self.base_size * 7), None)
-        self.down_bar_objects.set_touch_object("menu_4", button)
+        self.down_bar_objects.set_touch_object("menu_5", button)
 
         # Down bar
         self.down_bar = pygame.Surface(
@@ -143,17 +111,15 @@ class ScreenManager():
         self.mute_changed(self.core.playback.mute.get())
         self.playback_state_changed(self.core.playback.state.get(),
                                     self.core.playback.state.get())
-        self.screens[4].check_connection()
+        self.screens[menu_index].check_connection()
         self.change_screen(self.current_screen)
 
-        self.top_bar_objects.set_selected("pause_play")
 
     def update(self):
         surface = pygame.Surface(self.size)
         surface.fill([200, 200, 200])
         self.screens[self.current_screen].update(surface,
                                                  self.screen_changed)
-        surface.blit(self.top_bar, (0, 0))
         surface.blit(self.down_bar, (0, self.base_size * 7))
         self.top_bar_objects.render(surface)
         self.down_bar_objects.render(surface)
@@ -162,20 +128,11 @@ class ScreenManager():
 
     def track_started(self, track):
         self.track = track
-        self.screens[0].track_started(track.track)
-        self.screens[1].track_started(track)
-
-    def get_dirty_area(self):
-        self.dirty_area = self.dirty_area + self.top_bar_objects.get_dirty_area()
-        self.dirty_area = self.dirty_area + self.down_bar_objects.get_dirty_area()
-        self.dirty_area = self.dirty_area + self.screens[
-            self.current_screen].get_dirty_area()
-        dirty_area = self.dirty_area
-        self.dirty_area = []
-        return dirty_area
+        self.screens[main_screen_index].track_started(track.track)
+        self.screens[tracklist_index].track_started(track)
 
     def track_playback_ended(self, tl_track, time_position):
-        self.screens[0].track_playback_ended(tl_track, time_position)
+        self.screens[main_screen_index].track_playback_ended(tl_track, time_position)
 
     def event(self, event):
         event = self.input_manager.event(event)
@@ -200,91 +157,21 @@ class ScreenManager():
             self.screens[self.current_screen].touch_event(event)
 
     def volume_changed(self, volume):
-        if not self.core.playback.mute.get():
-            if volume > 80:
-                self.top_bar_objects.get_touch_object(
-                    "mute").set_text(
-                    u"\ue61f", False)
-            elif volume > 50:
-                self.top_bar_objects.get_touch_object(
-                    "mute").set_text(
-                    u"\ue620", False)
-            elif volume > 20:
-                self.top_bar_objects.get_touch_object(
-                    "mute").set_text(
-                    u"\ue621", False)
-            else:
-                self.top_bar_objects.get_touch_object(
-                    "mute").set_text(
-                    u"\ue622", False)
-        self.top_bar_objects.get_touch_object("volume").set_value(
-            volume)
+        self.screens[main_screen_index].volume_changed(volume)
 
-    def click_on_objects(self, objects, event):
-        if objects is not None:
-            for key in objects:
-                if 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.screens[4].check_connection()
-                elif key[:-1] == "menu_":
-                    self.change_screen(int(key[-1:]))
 
-    def change_volume(self, event):
-        manager = self.top_bar_objects
-        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 playback_state_changed(self, old_state, new_state):
-        if new_state == mopidy.core.PlaybackState.PLAYING:
-            self.top_bar_objects.get_touch_object(
-                "pause_play").set_text(u"\ue616", False)
-        else:
-            self.top_bar_objects.get_touch_object(
-                "pause_play").set_text(u"\ue615", False)
+        self.screens[main_screen_index].playback_state_changed(old_state, new_state)
 
     def mute_changed(self, mute):
-        self.top_bar_objects.get_touch_object("mute").set_active(
-            not mute)
-        if mute:
-            self.top_bar_objects.get_touch_object("mute").set_text(
-                u"\ue623", False)
-        else:
-            self.volume_changed(self.core.playback.volume.get())
+        self.screens[main_screen_index].mute_changed(mute)
 
     def tracklist_changed(self):
-        self.screens[1].tracklist_changed()
+        self.screens[tracklist_index].tracklist_changed()
 
     def options_changed(self):
-        self.top_bar_objects.get_touch_object("random").set_active(
-            self.core.tracklist.random.get())
-        self.top_bar_objects.get_touch_object("repeat").set_active(
-            self.core.tracklist.repeat.get())
-        self.top_bar_objects.get_touch_object("single").set_active(
-            self.core.tracklist.single.get())
+        self.screens[main_screen_index].options_changed()
 
     def change_screen(self, new_screen):
         self.screen_changed = True
@@ -296,17 +183,23 @@ class ScreenManager():
         self.dirty_area.append(
             pygame.Rect(0, 0, self.size[0], self.size[1]))
 
+    def click_on_objects(self, objects, event):
+        if objects is not None:
+            for key in objects:
+                if key[:-1] == "menu_":
+                    self.change_screen(int(key[-1:]))
+
     def playlists_loaded(self):
-        self.screens[3].playlists_loaded()
+        self.screens[playlist_index].playlists_loaded()
 
     def set_connection(self, connection, loading):
-        internet = self.top_bar_objects.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)
+        self.screens[main_screen_index].set_connection(connection, loading)
+
+    def check_connection(self):
+        self.screens[menu_index].check_connection()
+
+    def search(self, query, mode):
+        self.screens[search_index].search(query, mode)
 
     def change_selection(self, event, pos):
         if self.selected_zone == self.top_bar_objects:

mopidy_touchscreen/search_screen.py

@@ -0,0 +1,55 @@
+from .list_view import ListView
+import logging
+
+logger = logging.getLogger(__name__)
+
+mode_track_name = 0
+mode_album_name = 1
+mode_artist_name = 2
+
+
+class SearchScreen():
+    def __init__(self, size, base_size, manager):
+        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,
+                                  manager.fonts['base'])
+        self.results_strings = []
+        self.results = []
+
+    def update(self, screen, update_all):
+        self.list_view.render(screen)
+
+    def search(self, query, mode):
+        if mode == mode_track_name:
+            search_query = {'any': [query]}
+        elif mode == mode_album_name:
+            search_query = {'album': [query]}
+        else:
+            search_query = {'artist': [query]}
+        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):
+        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()

mopidy_touchscreen/tracklist.py

@@ -7,8 +7,8 @@ class Tracklist():
         self.size = size
         self.base_size = base_size
         self.manager = manager
-        self.list_view = ListView((0, self.base_size), (
-            self.size[0], self.size[1] - 2 * self.base_size),
+        self.list_view = ListView((0, 0), (
+            self.size[0], self.size[1] - self.base_size),
                                   self.base_size,
                                   manager.fonts['base'])
         self.tracks = []