Lower CPU usage

Screen will not be always updated

mopidy_touchscreen/graphic_utils/__init__.py

@@ -1,4 +1,4 @@
 # flake8: noqa
-from dynamic_background import DynamicBackground
+from background_manager import DynamicBackground
 from list_view import ListView
 from screen_objects import *

mopidy_touchscreen/graphic_utils/background_manager.py

@@ -0,0 +1,54 @@
+import pygame
+
+change_speed = 2
+
+
+class DynamicBackground():
+
+    def __init__(self, size):
+        self.image_loaded = False
+        self.size = size
+        self.surface = pygame.Surface(self.size).convert()
+        self.surface.fill((145, 16, 16))
+        self.surface_image = pygame.Surface(self.size).convert()
+        self.update = True
+
+    def draw_background(self):
+        if self.image_loaded:
+            return self.surface_image.copy()
+        else:
+            return self.surface.copy()
+
+    def should_update(self):
+        if self.update:
+            self.update = False
+            return True
+        else:
+            return False
+
+    def set_background_image(self, image):
+        if image is not None:
+            image_size = get_aspect_scale_size(image, self.size)
+            target = pygame.transform.smoothscale(image, image_size)
+            target.set_alpha(150)
+            self.image_loaded = True
+            self.surface_image.fill((0, 0, 0))
+            pos = ((self.size[0] - image_size[0])/2,
+                   (self.size[1] - image_size[1])/2)
+            self.surface_image.blit(target, pos)
+        else:
+            self.image_loaded = False
+        self.update = True
+
+
+def get_aspect_scale_size(img, (bx, by)):
+    size = img.get_size()
+    aspect_x = bx / float(size[0])
+    aspect_y = by / float(size[1])
+    if aspect_x > aspect_y:
+        aspect = aspect_x
+    else:
+        aspect = aspect_y
+
+    new_size = (int(aspect*size[0]), int(aspect*size[1]))
+    return new_size

mopidy_touchscreen/graphic_utils/dynamic_background.py

@@ -1,108 +0,0 @@
-import random
-
-import pygame
-
-
-change_speed = 2
-
-
-class DynamicBackground():
-
-    def __init__(self, size):
-        self.current = get_valid_color()
-        self.target = get_valid_color()
-        self.auto_mode = True
-        self.image_loaded = False
-        self.size = size
-        self.surface = pygame.Surface(self.size).convert()
-        self.target_current_same = False
-
-    def draw_background(self):
-        if self.image_loaded:
-            return self.surface.copy()
-        else:
-            if not self.target_current_same:
-                for x in range(0, 3):
-                    if abs(self.current[x]-self.target[x]) < change_speed:
-                        self.current[x] = self.target[x]
-                        self.target_current_same = True
-                    else:
-                        self.target_current_same = False
-                        if self.current[x] > self.target[x]:
-                            self.current[x] -= change_speed
-                        elif self.current[x] < self.target[x]:
-                            self.current[x] += change_speed
-            if self.auto_mode and self.target_current_same:
-                self.target = get_valid_color()
-                self.target_current_same = False
-            self.surface.fill(self.current)
-            return self.surface.copy()
-
-    def set_target_color(self, color, image):
-        if color is not None:
-            self.auto_mode = False
-            self.target_current_same = False
-            self.target = get_similar_valid_color(color)
-        else:
-            self.auto_mode = True
-            self.target = get_valid_color()
-            self.target_current_same = False
-
-        if image is not None:
-            image_size = get_aspect_scale_size(image, self.size)
-            target = pygame.transform.smoothscale(image, image_size)
-            target.set_alpha(150)
-            self.image_loaded = True
-            self.surface.fill((0, 0, 0))
-            pos = ((self.size[0] - image_size[0])/2,
-                   (self.size[1] - image_size[1])/2)
-            self.surface.blit(target, pos)
-        else:
-            self.image_loaded = False
-
-# It will return the same color if sum is less than 510
-# Otherwise a darker color will be returned
-# White text should be seen ok with this background color
-
-
-def get_similar_valid_color(color):
-    sum = color[0] + color[1] + color[2]
-    new_color = [0, 0, 0]
-    if sum > 510:
-        rest = (sum - 510)/3 + 1
-        for x in range(0, 3):
-            new_color[x] = color[x] - rest
-        return new_color
-    else:
-        return color
-
-# Returns an array with 3 integers in range of 0-255
-# The sum of the three integers will be lower than 255*2
-# (510) to avoid very bright colors
-# White text should be seen ok with this background color
-
-
-def get_valid_color():
-    color = [0, 0, 0]
-    total = 0
-    for i in range(0, 3):
-        color[i] = random.randint(0, 255)
-        total += color[i]
-    extra = total - 510
-    if extra > 0:
-        i = random.randint(0, 2)
-        color[i] -= extra
-    return color
-
-
-def get_aspect_scale_size(img, (bx, by)):
-    size = img.get_size()
-    aspect_x = bx / float(size[0])
-    aspect_y = by / float(size[1])
-    if aspect_x > aspect_y:
-        aspect = aspect_x
-    else:
-        aspect = aspect_y
-
-    new_size = (int(aspect*size[0]), int(aspect*size[1]))
-    return new_size

mopidy_touchscreen/graphic_utils/list_view.py

@@ -23,6 +23,7 @@ class ListView():
         self.selected = None
         self.active = []
         self.set_list([])
+        self.update_keys = []
 
     # Sets the list for the lisview.
     # It should be an iterable of strings
@@ -49,6 +50,7 @@ class ListView():
 
     # Will load items currently displaying in item_pos
     def load_new_item_position(self, item_pos):
+        self.update_keys = []
         self.current_item = item_pos
         if self.scrollbar:
             self.screen_objects.clear_touch(["scrollbar"])
@@ -60,19 +62,36 @@ class ListView():
             width = self.size[0] - self.base_size
         else:
             width = self.size[0]
+        self.should_update_always = False
         while i < self.list_size and z < self.max_rows:
             item = TouchAndTextItem(self.font, self.list[i], (
                 self.pos[0],
                 self.pos[1] + self.base_size * z), (width, -1))
+            if not item.fit_horizontal:
+                self.update_keys.append(str(i))
             self.screen_objects.set_touch_object(str(i), item)
             i += 1
             z += 1
         self.reload_selected()
 
-    def render(self, surface):
-        self.screen_objects.render(surface)
+    def should_update(self):
+        if len(self.update_keys) > 0:
+            return True
+        else:
+            return False
+
+    def render(self, surface, update_all, rects):
+        if update_all:
+            self.screen_objects.render(surface)
+        else:
+            for key in self.update_keys:
+                object = self.screen_objects.get_touch_object(key)
+                object.update()
+                object.render(surface)
+                rects.append(object.rect_in_pos)
 
     def touch_event(self, touch_event):
+        self.must_update = True
         if touch_event.type == InputManager.click \
                 or touch_event.type == InputManager.long_click:
             objects = self.screen_objects.get_touch_objects_in_pos(
@@ -127,6 +146,7 @@ class ListView():
 
     # Set active items
     def set_active(self, active):
+        self.must_update = True
         for number in self.active:
             try:
                 self.screen_objects.get_touch_object(
@@ -144,6 +164,7 @@ class ListView():
         self.active = active
 
     def set_selected(self, selected):
+        self.must_update = True
         if selected > -1 and selected < len(self.list):
             if self.selected is not None:
                 try:
@@ -163,6 +184,7 @@ class ListView():
             self.set_selected_on_screen()
 
     def set_selected_on_screen(self):
+        self.must_update = True
         if self.current_item + self.max_rows <= self.selected:
             self.move_to(1)
             self.set_selected_on_screen()
@@ -171,6 +193,7 @@ class ListView():
             self.set_selected_on_screen()
 
     def reload_selected(self):
+        self.must_update = True
         if self.selected is not None:
             try:
                 self.screen_objects.get_touch_object(

mopidy_touchscreen/graphic_utils/screen_objects.py

@@ -79,12 +79,12 @@ class BaseItem():
         return self.pos[0] + self.size[0]
 
     def update(self):
-        pass
+        return False
 
 
 class TextItem(BaseItem):
 
-    scroll_speed = 5
+    scroll_speed = 2
 
     def __init__(self, font, text, pos, size, center=False, background=None):
         self.font = font
@@ -228,7 +228,7 @@ class TouchAndTextItem(TouchObject, TextItem):
                                            self.active_color)
 
     def update(self):
-        TextItem.update(self)
+        return TextItem.update(self)
 
     def set_text(self, text, change_size):
         TextItem.set_text(self, text, change_size)

mopidy_touchscreen/input/input_manager.py

@@ -69,7 +69,6 @@ class InputManager():
     def key_down(self, event):
         if len(event.unicode) > 0 and event.key not in \
                 InputManager.special_keys:
-            print event
             return InputEvent(InputManager.key, None, None, None,
                               None, event.unicode)
         else:

mopidy_touchscreen/screen_manager.py

@@ -9,7 +9,7 @@ from pkg_resources import Requirement, resource_filename
 
 import pygame
 
-from screens import Keyboard, LibraryScreen, MainScreen, MenuScreen,\
+from screens import BaseScreen, Keyboard, LibraryScreen, MainScreen, MenuScreen,\
     PlaylistScreen, SearchScreen, Tracklist
 
 
@@ -24,6 +24,7 @@ menu_index = 5
 
 
 class ScreenManager():
+
     def __init__(self, size, core, cache):
         self.core = core
         self.cache = cache
@@ -40,6 +41,7 @@ class ScreenManager():
         self.down_bar_objects = ScreenObjectsManager()
         self.down_bar = None
         self.keyboard = None
+        self.update_type = BaseScreen.update_all
 
         self.init_manager(size)
 
@@ -51,8 +53,8 @@ class ScreenManager():
             Requirement.parse("mopidy-touchscreen"),
             "mopidy_touchscreen/icomoon.ttf")
         self.fonts['base'] = pygame.font.SysFont("arial",
-                                                 self.base_size)
-        self.fonts['icon'] = pygame.font.Font(font, self.base_size)
+                                                 int(self.base_size*0.9))
+        self.fonts['icon'] = pygame.font.Font(font, int(self.base_size*0.9))
         try:
             self.screens = [
                 SearchScreen(size, self.base_size, self, self.fonts),
@@ -131,15 +133,44 @@ class ScreenManager():
         self.screens[menu_index].check_connection()
         self.change_screen(self.current_screen)
 
-    def update(self):
-        surface = self.background.draw_background()
-        if self.keyboard:
-            self.keyboard.update(surface)
+        self.update_type = BaseScreen.update_all
+
+    def get_update_type(self):
+        if self.update_type == BaseScreen.update_all:
+            self.update_type = BaseScreen.no_update
+            return BaseScreen.update_all
         else:
-            self.screens[self.current_screen].update(surface)
-            surface.blit(self.down_bar, (0, self.base_size * 7))
-            self.down_bar_objects.render(surface)
-        return surface
+            if self.keyboard:
+                return BaseScreen.no_update
+            else:
+                if self.background.should_update():
+                    return BaseScreen.update_all
+                else:
+                    if self.screens[self.current_screen].should_update():
+                        return BaseScreen.update_partial
+                    else:
+                        return BaseScreen.no_update
+
+    def update(self, screen):
+        update_type = self.get_update_type()
+        if update_type != BaseScreen.no_update:
+            rects = []
+            surface = self.background.draw_background()
+            if self.keyboard:
+                self.keyboard.update(surface)
+            else:
+                self.screens[self.current_screen].\
+                    update(surface, update_type, rects)
+                surface.blit(self.down_bar, (0, self.base_size * 7))
+                self.down_bar_objects.render(surface)
+
+            if update_type == BaseScreen.update_all or len(rects) < 1:
+                screen.blit(surface, (0, 0))
+                pygame.display.flip()
+            else:
+                for rect in rects:
+                    screen.blit(surface, rect, area=rect)
+                pygame.display.update(rects)
 
     def track_started(self, track):
         self.track = track
@@ -157,6 +188,7 @@ class ScreenManager():
                 self.keyboard.touch_event(event)
             elif not self.manage_event(event):
                 self.screens[self.current_screen].touch_event(event)
+            self.update_type = BaseScreen.update_all
 
     def manage_event(self, event):
         if event.type == InputManager.click:
@@ -179,19 +211,24 @@ class ScreenManager():
 
     def volume_changed(self, volume):
         self.screens[main_screen_index].volume_changed(volume)
+        self.update_type = BaseScreen.update_all
 
     def playback_state_changed(self, old_state, new_state):
         self.screens[main_screen_index].playback_state_changed(
             old_state, new_state)
+        self.update_type = BaseScreen.update_all
 
     def mute_changed(self, mute):
         self.screens[main_screen_index].mute_changed(mute)
+        self.update_type = BaseScreen.update_all
 
     def tracklist_changed(self):
         self.screens[tracklist_index].tracklist_changed()
+        self.update_type = BaseScreen.update_all
 
     def options_changed(self):
         self.screens[main_screen_index].options_changed()
+        self.update_type = BaseScreen.update_all
 
     def change_screen(self, new_screen):
         if new_screen > -1 and new_screen < len(self.screens):
@@ -200,6 +237,7 @@ class ScreenManager():
             self.current_screen = new_screen
             self.down_bar_objects.get_touch_object(
                 "menu_" + str(new_screen)).set_active(True)
+        self.update_type = BaseScreen.update_all
 
     def click_on_objects(self, objects, event):
         if objects is not None:
@@ -211,23 +249,30 @@ class ScreenManager():
 
     def playlists_loaded(self):
         self.screens[playlist_index].playlists_loaded()
+        self.update_type = BaseScreen.update_all
 
     def set_connection(self, connection, loading):
         self.screens[main_screen_index].set_connection(connection,
                                                        loading)
+        self.update_type = BaseScreen.update_all
 
     def check_connection(self):
         self.screens[menu_index].check_connection()
+        self.update_type = BaseScreen.update_all
 
     def search(self, query, mode):
         self.screens[search_index].search(query, mode)
+        self.update_type = BaseScreen.update_all
 
     def resize(self, event):
         self.init_manager(event.size)
+        self.update_type = BaseScreen.update_all
 
     def open_keyboard(self, input_listener):
         self.keyboard = Keyboard(self.size, self.base_size, self,
                                  self.fonts, input_listener)
+        self.update_type = BaseScreen.update_all
 
     def close_keyboard(self):
         self.keyboard = None
+        self.update_type = BaseScreen.update_all

mopidy_touchscreen/screens/__init__.py

@@ -1,4 +1,5 @@
 # flake8: noqa
+from base_screen import BaseScreen
 from library_screen import LibraryScreen
 from keyboard_screen import Keyboard
 from main_screen import MainScreen

mopidy_touchscreen/screens/base_screen.py

@@ -1,12 +1,16 @@
 class BaseScreen():
 
+    update_all = 0
+    update_partial = 1
+    no_update = 2
+
     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):
+    def update(self, surface, update_type, rects):
         pass
 
     def event(self, event):
@@ -14,3 +18,6 @@ class BaseScreen():
 
     def change_screen(self, direction):
         return False
+
+    def should_update(self):
+        return BaseScreen.update_partial

mopidy_touchscreen/screens/keyboard_screen.py

@@ -13,20 +13,24 @@ class Keyboard(BaseScreen):
         self.base_height = size[1]/5
         self.listener = listener
         self.manager = manager
-        try:
-            self.font is None
-        except AttributeError:
-            self.font = pygame.font.SysFont("arial", size[1]/6)
+        self.selected_row = 0
+        self.selected_col = 0
+        self.selected_others = -1
+        self.font = pygame.font.SysFont("arial", size[1]/6)
         self.keyboards = [ScreenObjectsManager(), ScreenObjectsManager()]
         self.other_objects = ScreenObjectsManager()
         self.current_keyboard = 0
 
-        rows = [['q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p'],
-                ['a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', '-'],
-                [',', 'z', 'x', 'c', 'v', 'b', 'n', 'm', '.', '_']]
+        self.keys = [[['q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p'],
+                      ['a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', '-'],
+                      [',', 'z', 'x', 'c', 'v', 'b', 'n', 'm', '.', '_']],
+
+                     [['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'],
+                      ['!', '@', '#', '$', '%', '&', '/', '(', ')', '='],
+                      ['?', '{', '}', '_', '[', ']', '+', '<', '>', '*']]]
 
         line = self.base_height
-        for row in rows:
+        for row in self.keys[self.current_keyboard]:
             pos = 0
             for key in row:
                 button = \
@@ -40,11 +44,8 @@ class Keyboard(BaseScreen):
             line += self.base_height
 
         self.current_keyboard = 1
-        rows = [['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'],
-                ['!', '@', '#', '$', '%', '&', '/', '(', ')', '='],
-                ['?', '{', '}', '_', '[', ']', '+', '<', '>', '*']]
         line = self.base_height
-        for row in rows:
+        for row in self.keys[self.current_keyboard]:
             pos = 0
             for key in row:
                 button = \
@@ -91,6 +92,7 @@ class Keyboard(BaseScreen):
                                   (self.base_width*10, self.base_height),
                                   center=True)
         self.other_objects.set_object("text", button)
+        self.change_selected(0, 0)
 
     def update(self, screen):
         screen.fill((0, 0, 0))
@@ -107,10 +109,7 @@ class Keyboard(BaseScreen):
                 touch_event.current_pos)
             for key in keys:
                 if key == 'symbols':
-                    if self.current_keyboard == 0:
-                        self.current_keyboard = 1
-                    else:
-                        self.current_keyboard = 0
+                    self.change_keyboard()
                 elif key == "remove":
                     self.other_objects.get_object("text").remove_text(1, False)
                 elif key == "space":
@@ -120,9 +119,83 @@ class Keyboard(BaseScreen):
                     self.listener.text_input(text)
                     self.manager.close_keyboard()
         elif touch_event.type == InputManager.key:
-            if len(touch_event.unicode):
+            if isinstance(touch_event.unicode, unicode):
                 if touch_event.unicode == u'\x08':
                     self.other_objects.get_object("text").remove_text(1, False)
                 else:
                     self.other_objects.get_object("text").add_text(
                         touch_event.unicode, False)
+            elif touch_event.direction is not None:
+                x = 0
+                y = 0
+                if touch_event.direction == InputManager.left:
+                    x = -1
+                elif touch_event.direction == InputManager.right:
+                    x = 1
+                elif touch_event.direction == InputManager.up:
+                    y = -1
+                elif touch_event.direction == InputManager.down:
+                    y = 1
+                self.change_selected(x, y)
+
+    def change_keyboard(self):
+        if self.current_keyboard == 0:
+            self.current_keyboard = 1
+        else:
+            self.current_keyboard = 0
+        if self.selected_others < 0:
+            self.change_selected(0, 0)
+
+    def change_selected(self, x, y):
+        if self.selected_others < 0:
+            self.selected_row += x
+            if self.selected_row < 0:
+                self.selected_row = 0
+            elif self.selected_row > 9:
+                self.selected_row = 9
+            self.selected_col += y
+            if self.selected_col < 0:
+                self.selected_col = 0
+            elif self.selected_col > 2:
+                if self.selected_col < 2:
+                    self.selected_others = 0
+                elif self.selected_col < 8:
+                    self.selected_others = 1
+                else:
+                    self.selected_others = 2
+                self.set_selected_other()
+            if self.selected_others < 0:
+                key = self.keys[self.current_keyboard]
+                [self.selected_col][self.selected_row]
+                self.keyboards[self.current_keyboard].set_selected(key)
+            else:
+                self.keyboards[0].set_selected(None)
+                self.keyboards[0].set_selected(None)
+        else:
+            if y < 0:
+                self.selected_others = -1
+                self.set_selected_other()
+                self.selected_col = 2
+                self.selected_row = 0
+                key = self.keys[self.current_keyboard]
+                [self.selected_col][self.selected_row]
+                self.keyboards[self.current_keyboard].set_selected(key)
+            else:
+                self.selected_others += x
+                if self.selected_others < 0:
+                    self.selected_others = 0
+                elif self.selected_others > 3:
+                    self.selected_others = 3
+                self.set_selected_other()
+
+    def set_selected_other(self):
+        key = None
+        if self.selected_others == 0:
+            key = "symbols"
+        elif self.selected_others == 1:
+            key = "remove"
+        elif self.selected_others == 2:
+            key = "space"
+        elif self.selected_others == 3:
+            key = "ok"
+        self.other_objects.set_selected(key)

mopidy_touchscreen/screens/library_screen.py

@@ -37,8 +37,12 @@ class LibraryScreen(BaseScreen):
             self.current_directory = directory
             self.browse_uri(directory)
 
-    def update(self, screen):
-        self.list_view.render(screen)
+    def should_update(self):
+        return self.list_view.should_update()
+
+    def update(self, screen, update_type, rects):
+        update_all = (update_type == BaseScreen.update_all)
+        self.list_view.render(screen, update_all, rects)
 
     def touch_event(self, touch_event):
         clicked = self.list_view.touch_event(touch_event)

mopidy_touchscreen/screens/main_screen.py

@@ -31,7 +31,9 @@ class MainScreen(BaseScreen):
         self.cache = cache
         self.image = None
         self.artists = None
+        self.update_next_frame = True
         self.background = background
+        self.update_keys = []
         self.current_track_pos = 0
         self.track_duration = "00:00"
         self.touch_text_manager = ScreenObjectsManager()
@@ -89,29 +91,51 @@ class MainScreen(BaseScreen):
         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:
+    def should_update(self):
+        if len(self.update_keys) > 0:
+            return True
+        else:
             track_pos_millis = self.core.playback.time_position.get()
             new_track_pos = track_pos_millis / 1000
-            self.touch_text_manager.get_touch_object(
-                "time_progress").set_value(
-                track_pos_millis)
             if new_track_pos != self.current_track_pos:
+                return True
+            else:
+                return False
+
+    def update(self, screen, update_type, rects):
+        if update_type == BaseScreen.update_all:
+            screen.blit(self.top_bar, (0, 0))
+            self.touch_text_manager.render(screen)
+            if self.image is not None:
+                    screen.blit(self.image, (
+                        self.base_size / 2, self.base_size +
+                        self.base_size / 2))
+
+        elif update_type == BaseScreen.update_partial \
+                and self.track is not None:
+            track_pos_millis = self.core.playback.time_position.get()
+            new_track_pos = track_pos_millis / 1000
+
+            if new_track_pos != self.current_track_pos:
+                progress = self.touch_text_manager.get_touch_object(
+                    "time_progress")
+                progress.set_value(track_pos_millis)
                 self.current_track_pos = new_track_pos
-                self.touch_text_manager.get_touch_object(
-                    "time_progress").set_text(
+                progress.set_text(
                     time.strftime('%M:%S', time.gmtime(
                         self.current_track_pos)) +
                     "/" + 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
+                progress.render(screen)
+                rects.append(progress.rect_in_pos)
+
+            for key in self.update_keys:
+                object = self.touch_text_manager.get_touch_object(key)
+                object.update()
+                object.render(screen)
+                rects.append(object.rect_in_pos)
 
     def track_started(self, track):
+        self.update_keys = []
         self.image = None
         x = self.base_size * 5
         width = self.size[0] - self.base_size / 2 - x
@@ -128,6 +152,8 @@ class MainScreen(BaseScreen):
         label = TouchAndTextItem(self.fonts['base'],
                                  MainScreen.get_track_name(track),
                                  (x, self.base_size * 2), (width, -1))
+        if not label.fit_horizontal:
+            self.update_keys.append("track_name")
         self.touch_text_manager.set_touch_object("track_name", label)
 
         # Album name
@@ -135,6 +161,8 @@ class MainScreen(BaseScreen):
                                  MainScreen.get_track_album_name
                                  (track), (x, self.base_size * 3),
                                  (width, -1))
+        if not label.fit_horizontal:
+            self.update_keys.append("album_name")
         self.touch_text_manager.set_touch_object("album_name", label)
 
         # Artist
@@ -142,6 +170,8 @@ class MainScreen(BaseScreen):
                                  self.get_artist_string(),
                                  (x, self.base_size * 4),
                                  (width, -1))
+        if not label.fit_horizontal:
+            self.update_keys.append("artist_name")
         self.touch_text_manager.set_touch_object("artist_name", label)
 
         # Previous track button
@@ -251,6 +281,8 @@ class MainScreen(BaseScreen):
                                        (self.base_size / 2,
                                         self.base_size * 2),
                                        (width, -1))
+            if not current.fit_horizontal:
+                self.update_keys.append("track_name")
             self.touch_text_manager.set_touch_object("track_name",
                                                      current)
 
@@ -260,6 +292,8 @@ class MainScreen(BaseScreen):
                                        (self.base_size / 2,
                                         self.base_size * 3),
                                        (width, -1))
+            if not current.fit_horizontal:
+                self.update_keys.append("album_name")
             self.touch_text_manager.set_touch_object("album_name",
                                                      current)
 
@@ -268,11 +302,15 @@ class MainScreen(BaseScreen):
                                        (self.base_size / 2,
                                         self.base_size * 4),
                                        (width, -1))
+            if not current.fit_horizontal:
+                self.update_keys.append("artist_name")
             self.touch_text_manager.set_touch_object("artist_name",
                                                      current)
 
+            self.background.set_background_image(None)
+
     def track_playback_ended(self, tl_track, time_position):
-        self.background.set_target_color(None, None)
+        self.background.set_background_image(None)
         self.image = None
         self.track_duration = "00:00"
 
@@ -306,9 +344,8 @@ class MainScreen(BaseScreen):
             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
+        self.background.set_background_image(image_original)
 
     def touch_event(self, event):
         if event.type == InputManager.click:

mopidy_touchscreen/screens/menu_screen.py

@@ -16,8 +16,12 @@ class MenuScreen(BaseScreen):
 
         self.list.set_list(self.list_items)
 
-    def update(self, screen):
-        self.list.render(screen)
+    def should_update(self):
+        return self.list.should_update()
+
+    def update(self, screen, update_type, rects):
+        update_all = (update_type == BaseScreen.update_all)
+        self.list.render(screen, update_all, rects)
 
     def touch_event(self, event):
         clicked = self.list.touch_event(event)

mopidy_touchscreen/screens/playlist_screen.py

@@ -17,8 +17,12 @@ class PlaylistScreen(BaseScreen):
         self.playlist_tracks_strings = []
         self.playlists_loaded()
 
-    def update(self, screen):
-        self.list_view.render(screen)
+    def should_update(self):
+        return self.list_view.should_update()
+
+    def update(self, screen, update_type, rects):
+        update_all = (update_type == BaseScreen.update_all)
+        self.list_view.render(screen, update_all, rects)
 
     def playlists_loaded(self):
         self.selected_playlist = None

mopidy_touchscreen/screens/search_screen.py

@@ -73,10 +73,14 @@ class SearchScreen(BaseScreen):
         self.set_mode(mode=mode_track_name)
         self.set_query("Search")
 
-    def update(self, screen):
+    def should_update(self):
+        return self.list_view.should_update()
+
+    def update(self, screen, update_type, rects):
         screen.blit(self.top_bar, (0, 0))
         self.screen_objects.render(screen)
-        self.list_view.render(screen)
+        update_all = (update_type == BaseScreen.update_all)
+        self.list_view.render(screen, update_all, rects)
 
     def set_mode(self, mode=mode_track_name):
         if mode is not self.mode:

mopidy_touchscreen/screens/tracklist.py

@@ -19,8 +19,12 @@ class Tracklist(BaseScreen):
         self.track_started(
             self.manager.core.playback.current_tl_track.get())
 
-    def update(self, screen):
-        self.list_view.render(screen)
+    def should_update(self):
+        return self.list_view.should_update()
+
+    def update(self, screen, update_type, rects):
+        update_all = (update_type == BaseScreen.update_all)
+        self.list_view.render(screen, update_all, rects)
 
     def tracklist_changed(self):
         self.update_list()

mopidy_touchscreen/touch_screen.py

@@ -75,10 +75,10 @@ class TouchScreen(pykka.ThreadingActor, core.CoreListener):
 
     def start_thread(self):
         clock = pygame.time.Clock()
+        pygame.event.set_blocked(pygame.MOUSEMOTION)
         while self.running:
-            clock.tick(20)
-            self.screen.blit(self.screen_manager.update(), (0, 0))
-            pygame.display.flip()
+            clock.tick(12)
+            self.screen_manager.update(self.screen)
             for event in pygame.event.get():
                 if event.type == pygame.QUIT:
                     os.system("pkill mopidy")