Cleanup

mopidy_touchscreen/base_screen.py

@@ -1,6 +1,3 @@
-__author__ = 'ander'
-
-
 class BaseScreen():
 
     def __init__(self, size, base_size, manager, fonts):

mopidy_touchscreen/dynamic_background.py

@@ -1,5 +1,5 @@
 import random
-import logging
+
 
 change_speed = 2
 

mopidy_touchscreen/input_manager.py

@@ -111,8 +111,8 @@ class InputManager():
                 return InputEvent(InputManager.swipe, self.down_pos,
                                   self.up_pos, True, None)
         elif self.down_pos[1] - self.up_pos[1] < self.max_move_margin:
-            if abs(self.down_pos[0] - self.up_pos[
-                0]) > self.min_swipe_move:
+            if abs(self.down_pos[0] - self.up_pos[0]) > \
+                    self.min_swipe_move:
                 return InputEvent(InputManager.swipe, self.down_pos,
                                   self.up_pos, False, None)
 

mopidy_touchscreen/library_screen.py

@@ -54,15 +54,14 @@ class LibraryScreen(BaseScreen):
                 if clicked == 0:
                     self.go_up_directory()
                 else:
-                    if self.library[
-                                clicked - 1].type == mopidy.models.Ref.TRACK:
+                    if self.library[clicked - 1].type\
+                            == mopidy.models.Ref.TRACK:
                         self.play_uri(self.current_directory, clicked-1)
                     else:
                         self.go_inside_directory(
                             self.library[clicked - 1].uri)
             else:
-                 self.go_inside_directory(
-                        self.library[clicked].uri)
+                self.go_inside_directory(self.library[clicked].uri)
 
     def play_uri(self, uri, track_pos):
         self.manager.core.tracklist.clear()
@@ -71,7 +70,9 @@ class LibraryScreen(BaseScreen):
             if item.type == mopidy.models.Ref.TRACK:
                 tracks.append(self.manager.core.library.lookup(item.uri).get()[0])
             else:
-                track_pos = track_pos - 1
+                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])
+        self.manager.core.playback.play(
+            tl_track=self.manager.core.tracklist.tl_tracks.get()
+            [track_pos])
 

mopidy_touchscreen/list_view.py

@@ -20,10 +20,11 @@ class ListView():
         self.list = []
         self.scrollbar = False
         self.selected = None
-        self.set_list([])
         self.active = []
+        self.set_list([])
 
-    # Sets the list for the lisview. It should be an iterable of strings
+    # Sets the list for the lisview.
+    # It should be an iterable of strings
     def set_list(self, item_list):
         self.screen_objects.clear()
         self.list = item_list
@@ -98,7 +99,6 @@ class ListView():
             elif touch_event.direction == InputManager.down:
                 self.move_to(1)
 
-
     # Scroll to direction
     # direction == 1 will scroll down
     # direction == -1 will scroll up
@@ -122,7 +122,6 @@ class ListView():
                     self.current_item)
             self.set_active(self.active)
 
-
     # Set active items
     def set_active(self, active):
         for number in self.active:

mopidy_touchscreen/main_screen.py

@@ -8,10 +8,9 @@ import urllib
 import urllib2
 from threading import Thread
 import pygame
-from .base_screen import BaseScreen
 
+from .base_screen import BaseScreen
 from .screen_objects import (Progressbar, ScreenObjectsManager,
-                             TextItem,
                              TouchAndTextItem)
 from .input_manager import InputManager
 
@@ -20,7 +19,8 @@ logger = logging.getLogger(__name__)
 
 
 class MainScreen(BaseScreen):
-    def __init__(self, size, base_size, manager, fonts, cache, core, background):
+    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
@@ -35,8 +35,7 @@ class MainScreen(BaseScreen):
             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)
@@ -94,10 +93,12 @@ class MainScreen(BaseScreen):
             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)
+                    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.base_size / 2, self.base_size +
+                    self.base_size / 2))
         self.touch_text_manager.render(screen)
         return screen
 
@@ -116,22 +117,22 @@ class MainScreen(BaseScreen):
 
         # Track name
         label = TouchAndTextItem(self.fonts['base'],
-                         MainScreen.get_track_name(track),
-                         (x, self.base_size * 2),
-                         (width, -1))
+                                 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))
+                                 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))
+        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
@@ -150,9 +151,8 @@ class MainScreen(BaseScreen):
         # Progress
         progress = Progressbar(self.fonts['base'],
                                time.strftime('%M:%S', time.gmtime(
-                                   0)) + "/" + time.strftime('%M:%S',
-                                                             time.gmtime(
-                                                                 0)),
+                                   0)) + "/" + time.strftime(
+                                   '%M:%S', time.gmtime(0)),
                                (size_1, self.base_size * 6),
                                (
                                    self.size[0] - size_1 - size_2,
@@ -220,30 +220,35 @@ class MainScreen(BaseScreen):
 
             logger.info("Cover could not be downloaded")
 
-            # There is no cover so it will use all the screen size for the text
+            # 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)
+                                       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)
+                                       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)
+                                       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)
@@ -253,34 +258,40 @@ class MainScreen(BaseScreen):
         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)
+                                   (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)
+                                   (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)
+                                   (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 = pygame.transform.scale(pygame.image.load(
-                self.get_cover_folder() +
-                self.get_image_file_name()).convert(),
-            (size, size))
-        self.background.set_target_color(pygame.transform.average_color(image))
+            self.get_cover_folder() +
+            self.get_image_file_name()).convert(), (size, size))
+        self.background.set_target_color(
+            pygame.transform.average_color(image))
         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)
+            objects = \
+                self.touch_text_manager.get_touch_objects_in_pos(
+                    event.current_pos)
             if objects is not None:
                 self.click_on_objects(objects, event)
 
@@ -301,13 +312,13 @@ class MainScreen(BaseScreen):
                     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(
+                        key).get_pos_value(
                         event.current_pos) * 1000
                     self.core.playback.seek(value)
 
@@ -353,7 +364,7 @@ class MainScreen(BaseScreen):
         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:
@@ -374,7 +385,7 @@ class MainScreen(BaseScreen):
                     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())
@@ -391,7 +402,7 @@ class MainScreen(BaseScreen):
                 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(
@@ -399,9 +410,10 @@ class MainScreen(BaseScreen):
         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")
+        internet = self.touch_text_manager.get_touch_object(
+            "internet")
         if loading:
             internet.set_text(u"\ue627", None)
             internet.set_active(False)
@@ -409,7 +421,6 @@ class MainScreen(BaseScreen):
             internet.set_text(u"\ue602", None)
             internet.set_active(connection)
 
-
     @staticmethod
     def get_track_name(track):
         if track.name is None:
@@ -419,8 +430,8 @@ class MainScreen(BaseScreen):
 
     @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:
+        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/menu_screen.py

@@ -66,10 +66,10 @@ class MenuScreen(BaseScreen):
                     mopidy.utils.process.exit_process()
                 elif key == "shutdown_icon" or key == "shutdown":
                     if os.system("gksu -- shutdown now -h") != 0:
-                        os.system("shutdown now -h")
+                        os.system("sudo shutdown now -h")
                 elif key == "restart_icon" or key == "restart":
                     if os.system("gksu -- shutdown -r now") != 0:
-                        os.system("shutdown -r now")
+                        os.system("sudo shutdown -r now")
                 elif key == "ip":
                     self.check_connection()
 

mopidy_touchscreen/playlist_screen.py

@@ -6,9 +6,9 @@ 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.size[0], self.size[1] -
+            self.base_size), self.base_size,
+            self.fonts['base'])
         self.playlists_strings = []
         self.playlists = []
         self.playlists_loaded()
@@ -36,7 +36,6 @@ class PlaylistScreen(BaseScreen):
             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:
@@ -48,9 +47,9 @@ class PlaylistScreen(BaseScreen):
                     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])
-            #self.manager.core.tracklist.clear()
-            #self.manager.core.tracklist.add(
-            #    uri=self.playlists[clicked].uri)
-            #self.manager.core.playback.play()
+                    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/screen_manager.py

@@ -31,8 +31,19 @@ class ScreenManager():
         self.fonts = {}
         self.background = DynamicBackground()
         self.current_screen = library_index
-        self.init_manager(size)
 
+        # Init variables in init
+        self.base_size = None
+        self.size = None
+        self.screens = None
+        self.track = None
+        self.screen_changed = None
+        self.input_manager = InputManager(size)
+        self.down_bar_objects = ScreenObjectsManager()
+        self.down_bar_solid = None
+        self.down_bar = None
+
+        self.init_manager(size)
 
     def init_manager(self, size):
         self.size = size
@@ -40,29 +51,29 @@ class ScreenManager():
         font = resource_filename(
             Requirement.parse("mopidy-touchscreen"),
             "mopidy_touchscreen/icomoon.ttf")
-        self.fonts['base'] = pygame.font.SysFont("verdana",
+        self.fonts['base'] = pygame.font.SysFont("arial",
                                                  self.base_size)
         self.fonts['icon'] = pygame.font.Font(font, self.base_size)
         try:
             self.screens = [
                 SearchScreen(size, self.base_size, self, self.fonts),
-                MainScreen(size, self.base_size, self, self.fonts, self.cache, self.core, self.background),
+                MainScreen(size, self.base_size, self, self.fonts,
+                           self.cache, self.core, self.background),
                 Tracklist(size, self.base_size, self, self.fonts),
                 LibraryScreen(size, self.base_size, self, self.fonts),
-                PlaylistScreen(size, self.base_size, self, self.fonts),
+                PlaylistScreen(size,
+                               self.base_size, self, self.fonts),
                 MenuScreen(size, self.base_size, self, self.fonts)]
         except:
             traceback.print_exc()
         self.track = None
-        self.input_manager = InputManager(size)
-        self.down_bar_objects = ScreenObjectsManager()
         self.screen_changed = True
 
         # Menu buttons
 
         button_size = (self.size[0] / 6, self.base_size)
 
-         # Search button
+        # Search button
         button = TouchAndTextItem(self.fonts['icon'], u" \ue986",
                                   (0, self.base_size * 7),
                                   button_size, center=True)
@@ -100,7 +111,9 @@ class ScreenManager():
 
         # Menu button
         button = TouchAndTextItem(self.fonts['icon'], u" \ue60a",
-                                  (x, self.base_size * 7), button_size, center=True)
+                                  (x, self.base_size * 7),
+                                  button_size,
+                                  center=True)
         self.down_bar_objects.set_touch_object("menu_5", button)
 
         # Down bar Solid
@@ -109,9 +122,9 @@ class ScreenManager():
 
         # Down bar
         self.down_bar = pygame.Surface(
-            (self.size[0], self.size[1] - self.base_size * 7), pygame.SRCALPHA)
-        self.down_bar.fill((0,0,0,200))
-
+            (self.size[0], self.size[1] - self.base_size * 7),
+            pygame.SRCALPHA)
+        self.down_bar.fill((0, 0, 0, 200))
 
         self.options_changed()
         self.mute_changed(self.core.playback.mute.get())
@@ -122,7 +135,8 @@ class ScreenManager():
 
     def update(self):
         surface = pygame.Surface(self.size)
-        self.background.draw_background([surface, self.down_bar_solid])
+        self.background.draw_background([surface,
+                                         self.down_bar_solid])
         self.screens[self.current_screen].update(surface,
                                                  self.screen_changed)
         surface.blit(self.down_bar_solid, (0, self.base_size * 7))
@@ -137,7 +151,8 @@ class ScreenManager():
         self.screens[tracklist_index].track_started(track)
 
     def track_playback_ended(self, tl_track, time_position):
-        self.screens[main_screen_index].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)
@@ -147,7 +162,9 @@ class ScreenManager():
 
     def manage_event(self, event):
         if event.type == InputManager.click:
-            objects = self.down_bar_objects.get_touch_objects_in_pos(event.current_pos)
+            objects = \
+                self.down_bar_objects.get_touch_objects_in_pos(
+                    event.current_pos)
             return self.click_on_objects(objects, event)
         else:
             if event.type == InputManager.key:
@@ -163,7 +180,8 @@ class ScreenManager():
         self.screens[main_screen_index].volume_changed(volume)
 
     def playback_state_changed(self, old_state, new_state):
-        self.screens[main_screen_index].playback_state_changed(old_state, new_state)
+        self.screens[main_screen_index].playback_state_changed(
+            old_state, new_state)
 
     def mute_changed(self, mute):
         self.screens[main_screen_index].mute_changed(mute)
@@ -194,7 +212,8 @@ class ScreenManager():
         self.screens[playlist_index].playlists_loaded()
 
     def set_connection(self, connection, loading):
-        self.screens[main_screen_index].set_connection(connection, loading)
+        self.screens[main_screen_index].set_connection(connection,
+                                                       loading)
 
     def check_connection(self):
         self.screens[menu_index].check_connection()

mopidy_touchscreen/screen_objects.py

@@ -31,7 +31,6 @@ class ScreenObjectsManager():
     def get_touch_object(self, key):
         return self.touch_objects[key]
 
-
     def render(self, surface):
         for key in self.text_objects:
             self.text_objects[key].update()
@@ -68,6 +67,7 @@ class ScreenObjectsManager():
             self.selected_key = None
 
     def change_selected(self, direction, pos):
+        best_key = None
         if pos is None:
             pos = self.selected.pos
         if direction == InputManager.right:
@@ -208,7 +208,6 @@ class BaseItem():
     def get_right_pos(self):
         return self.pos[0] + self.size[0]
 
-
     def update(self):
         pass
 
@@ -217,7 +216,6 @@ class TextItem(BaseItem):
 
     scroll_speed = 5
 
-
     def __init__(self, font, text, pos, size, center=False):
         self.font = font
         self.text = text
@@ -252,16 +250,19 @@ class TextItem(BaseItem):
         self.center = center
         if self.center:
             if self.fit_horizontal:
-                self.margin = (self.size[0]-self.box.get_rect().width)/2
+                self.margin = (self.size[0]-
+                               self.box.get_rect().width)/2
 
     def update(self):
         if not self.fit_horizontal:
-            self.step = self.step + TextItem.scroll_speed
+            self.step += TextItem.scroll_speed
             if self.step_2 is None:
-                if (self.box.get_rect().width - self.step + self.scroll_white_gap) < self.size[0]:
-                    self.step_2 = self.box.get_rect().width - self.step + self.scroll_white_gap
+                if (self.box.get_rect().width - self.step +
+                        self.scroll_white_gap) < self.size[0]:
+                    self.step_2 = self.box.get_rect().width \
+                                  - self.step + self.scroll_white_gap
             else:
-                self.step_2 = self.step_2 - TextItem.scroll_speed
+                self.step_2 -= TextItem.scroll_speed
                 if self.step_2 < 0:
                     self.step = 0 - self.step_2
                     self.step_2 = None
@@ -277,9 +278,10 @@ class TextItem(BaseItem):
                          area=pygame.Rect(self.step, 0, self.size[0],
                                           self.size[1]))
             if self.step_2 is not None:
-                surface.blit(self.box, (self.pos[0]+self.step_2, self.pos[1]),
-                         area=pygame.Rect(0, 0, self.size[0] - self.step_2,
-                                          self.size[1]))
+                surface.blit(self.box, (self.pos[0]+self.step_2,
+                                        self.pos[1]),
+                             area=pygame.Rect(0, 0, self.size[0] - self.step_2,
+                                              self.size[1]))
 
     def set_text(self, text, change_size):
         if text != self.text:
@@ -296,9 +298,13 @@ class TouchObject(BaseItem):
         BaseItem.__init__(self, pos, size)
         self.active = False
         self.selected = False
-        self.selected_box = pygame.Surface(size,pygame.SRCALPHA)
-        self.selected_box.fill((0,0,0,128))
-        pygame.draw.rect(self.selected_box, (255,255,255), self.selected_box.get_rect(), size[1]/10+1)
+        self.selected_box = pygame.Surface(size, pygame.SRCALPHA)
+        self.selected_box.fill((0, 0, 0, 128))
+        self.selected_box_rectangle = pygame.Surface(size,
+                                                     pygame.SRCALPHA)
+        pygame.draw.rect(self.selected_box_rectangle, (255, 255, 255),
+                         self.selected_box_rectangle.get_rect(),
+                         size[1]/10+1)
 
     def is_pos_inside(self, pos):
         return self.rect_in_pos.collidepoint(pos)
@@ -310,16 +316,24 @@ class TouchObject(BaseItem):
         self.selected = selected
 
     def render(self, surface):
+        if self.selected:
+            surface.blit(self.selected_box, self.pos)
+            surface.blit(self.selected_box_rectangle, self.pos)
+
+    def pre_render(self, surface):
         if self.selected:
             surface.blit(self.selected_box, self.pos)
 
+    def post_render(self, surface):
+        if self.selected:
+            surface.blit(self.selected_box_rectangle, self.pos)
+
 
 class TouchAndTextItem(TouchObject, TextItem):
     def __init__(self, font, text, pos, size, center=False):
         TextItem.__init__(self, font, text, pos, size, center=center)
         TouchObject.__init__(self, pos, self.size)
         self.active_color = (0, 150, 255)
-        self.selected_color = (150, 0, 255)
         self.normal_box = self.box
         self.active_box = self.font.render(text, True,
                                            self.active_color)
@@ -341,8 +355,9 @@ class TouchAndTextItem(TouchObject, TextItem):
             self.box = self.normal_box
 
     def render(self, surface):
-        TouchObject.render(self, surface)
+        TouchObject.pre_render(self, surface)
         TextItem.render(self, surface)
+        TouchObject.post_render(self, surface)
 
 
 class Progressbar(TouchObject):
@@ -357,16 +372,16 @@ class Progressbar(TouchObject):
         self.value_text = value_text
         if value_text:
             self.text = TextItem(font, str(max_value), pos, None)
-            self.text.pos = (
-            self.pos[0] + self.size[0] / 2 - self.text.size[0] /
-            2, self.text.pos[1])
+            self.text.pos = (self.pos[0]
+                             + self.size[0] / 2 -
+                             self.text.size[0] /
+                             2, self.text.pos[1])
             self.text.set_text(str(self.value), True)
         else:
             self.text = TextItem(font, text, pos, None)
             self.text.pos = (
-            self.pos[0] + self.size[0] / 2 - self.text.size[0] /
-            2, self.text.pos[1])
-
+                self.pos[0] + self.size[0] / 2 - self.text.size[0] /
+                2, self.text.pos[1])
 
     def render(self, surface):
         surface.blit(self.surface, self.pos)
@@ -377,9 +392,10 @@ class Progressbar(TouchObject):
             self.value = value
             if self.value_text:
                 self.set_text(str(self.value))
-                self.text.pos = (
-                self.pos[0] + self.size[0] / 2 - self.text.size[0] /
-                2, self.text.pos[1])
+                self.text.pos = (self.pos[0]
+                                 + self.size[0] / 2 -
+                                 self.text.size[0]
+                                 / 2, self.text.pos[1])
             self.surface.fill(self.back_color)
             pos_pixel = value * self.size[0] / self.max
             rect = pygame.Rect(0, 0, pos_pixel, self.size[1])

mopidy_touchscreen/search_screen.py

@@ -20,40 +20,43 @@ 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.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)
+        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"]
+        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)
+        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)
+        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)
-
+        self.screen_objects.set_touch_object(
+            self.mode_objects_keys[2], button)
 
         # Top Bar
         self.top_bar = pygame.Surface(
@@ -74,12 +77,15 @@ class SearchScreen(BaseScreen):
         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)
+                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)
+        self.screen_objects.get_object("query").set_text(
+            self.query, False)
 
     def search(self, query=None, mode=None):
         if query is not None:
@@ -92,8 +98,9 @@ class SearchScreen(BaseScreen):
             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()
+        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:
@@ -109,8 +116,6 @@ class SearchScreen(BaseScreen):
                     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)
@@ -120,7 +125,8 @@ class SearchScreen(BaseScreen):
                     uri=self.results[clicked].uri)
                 self.manager.core.playback.play()
             else:
-                clicked = self.screen_objects.get_touch_objects_in_pos(touch_event.down_pos)
+                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]:
@@ -130,4 +136,4 @@ class SearchScreen(BaseScreen):
                     if clicked == self.mode_objects_keys[2]:
                         self.search(mode=2)
         else:
-            self.list_view.touch_event(touch_event)
+            self.list_view.touch_event(touch_event)

mopidy_touchscreen/tracklist.py

@@ -10,10 +10,13 @@ class Tracklist(BaseScreen):
         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.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, update_all):
         self.list_view.render(screen)