Update only some parts of the display

mopidy_touchscreen/graphic_utils/background_manager.py

@@ -18,6 +18,15 @@ class DynamicBackground:
         self.screen_change_percent = 100
 
     def draw_background(self):
+        self.update_background()
+        return self.surface.copy()
+
+    def draw_background_in_rects(self, surface, rects):
+        self.update_background()
+        for rect in rects:
+            surface.blit(self.surface, rect, area=rect)
+
+    def update_background(self):
         if self.image_loaded:
             if self.screen_change_percent < 255:
                 self.surface.fill((0, 0, 0))
@@ -28,7 +37,6 @@ class DynamicBackground:
                 self.surface.blit(self.surface_image, (0, 0))
                 self.screen_change_percent += 5
                 self.update = True
-        return self.surface.copy()
 
     def should_update(self):
         if self.update:

mopidy_touchscreen/graphic_utils/list_view.py

@@ -82,6 +82,11 @@ class ListView():
         else:
             return False
 
+    def find_update_rects(self, rects):
+        for key in self.update_keys:
+            object = self.screen_objects.get_touch_object(key)
+            rects.append(object.rect_in_pos)
+
     def render(self, surface, update_all, rects):
         if update_all:
             self.screen_objects.render(surface)
@@ -90,7 +95,6 @@ class ListView():
                 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

mopidy_touchscreen/screen_manager.py

@@ -1,4 +1,5 @@
 import logging
+import random
 import traceback
 
 from graphic_utils import DynamicBackground, \
@@ -49,6 +50,8 @@ class ScreenManager():
 
         self.init_manager(size)
 
+        self.last_surface = pygame.Surface(size)
+
     def init_manager(self, size):
         self.size = size
         self.base_size = self.size[1] / self.resolution_factor
@@ -63,73 +66,48 @@ class ScreenManager():
             "mopidy_touchscreen/NotoSans-Regular.ttf")
         self.fonts['base'] = pygame.font.Font(font_base, int(self.base_size*0.9))
         self.fonts['icon'] = pygame.font.Font(font_icon, int(self.base_size*0.9))
-        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),
-                Tracklist(size, self.base_size, self, self.fonts),
-                LibraryScreen(size, self.base_size, self, self.fonts),
-                PlaylistScreen(size,
-                               self.base_size, self, self.fonts),
-                MenuScreen(size, self.base_size, self, self.fonts, self.core)]
-        except:
-            traceback.print_exc()
+
         self.track = None
 
         # Menu buttons
 
         button_size = (self.size[0] / 6, self.base_size)
 
-        # Search button
-        button = TouchAndTextItem(self.fonts['icon'], u" \ue986",
-                                  (0, self.size[1] - self.base_size),
-                                  button_size, center=True)
-        self.down_bar_objects.set_touch_object("menu_0", button)
-        x = button.get_right_pos()
-
-        # Main button
-        button = TouchAndTextItem(self.fonts['icon'], u" \ue600",
-                                  (x, self.size[1] - self.base_size),
-                                  button_size, center=True)
-        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.size[1] - self.base_size),
-                                  button_size, center=True)
-        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.size[1] - self.base_size),
-                                  button_size, center=True)
-        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.size[1] - self.base_size),
-                                  button_size, center=True)
-
-        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.size[1] - self.base_size),
-                                  button_size,
-                                  center=True)
-        self.down_bar_objects.set_touch_object("menu_5", button)
+        menu_icons = [u" \ue986", u" \ue600", u"\ue60d", u" \ue604", u" \ue605", u" \ue60a"]
+
+        x = 0
+        i = 0
+        while(i<6):
+
+            button = TouchAndTextItem(self.fonts['icon'], menu_icons[i],
+                                    (x, self.size[1] - self.base_size),
+                                    button_size, center=True)
+            self.down_bar_objects.set_touch_object("menu_" + str(i), button)
+            x = button.get_right_pos()
+            i += 1
+            button.pos = (button.pos[0], self.size[1] - button.rect_in_pos.size[1])
 
         # Down bar
         self.down_bar = pygame.Surface(
-            (self.size[0], self.size[1] - self.base_size),
+            (self.size[0], button.rect_in_pos.size[1]),
             pygame.SRCALPHA)
         self.down_bar.fill((0, 0, 0, 200))
 
+        screen_size = (size[0], self.size[1] - button.rect.size[1])
+
+        try:
+            self.screens = [
+                SearchScreen(screen_size, self.base_size, self, self.fonts),
+                MainScreen(screen_size, self.base_size, self, self.fonts,
+                           self.cache, self.core, self.background),
+                Tracklist(screen_size, self.base_size, self, self.fonts),
+                LibraryScreen(screen_size, self.base_size, self, self.fonts),
+                PlaylistScreen(screen_size,
+                               self.base_size, self, self.fonts),
+                MenuScreen(screen_size, self.base_size, self, self.fonts, self.core)]
+        except:
+            traceback.print_exc()
+
         self.options_changed()
         self.mute_changed(self.core.playback.mute.get())
         playback_state = self.core.playback.state.get()
@@ -161,22 +139,29 @@ class ScreenManager():
         update_type = self.get_update_type()
         if update_type != BaseScreen.no_update:
             rects = []
-            surface = self.background.draw_background()
+            if update_type == BaseScreen.update_partial:
+                surface = self.last_surface
+                self.screens[self.current_screen].find_update_rects(rects)
+                self.background.draw_background_in_rects(surface, rects)
+            else:
+                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.size[1] - self.base_size))
+                surface.blit(self.down_bar, (0, self.size[1] - self.down_bar.get_size()[1]))
                 self.down_bar_objects.render(surface)
 
-            if update_type == BaseScreen.update_all or len(rects) < 1:
+            if update_type == BaseScreen.update_all:
                 screen.blit(surface, (0, 0))
                 pygame.display.flip()
             else:
                 for rect in rects:
                     screen.blit(surface, rect, area=rect)
-                pygame.display.update(rects)
+                    pygame.display.update(rects)
+            self.last_surface = surface
 
     def track_started(self, track):
         self.track = track

mopidy_touchscreen/screens/base_screen.py

@@ -10,6 +10,9 @@ class BaseScreen():
         self.manager = manager
         self.fonts = fonts
 
+    def find_update_rects(self, rects):
+        pass
+
     def update(self, surface, update_type, rects):
         """
         Draw this screen to the surface

mopidy_touchscreen/screens/library_screen.py

@@ -8,9 +8,7 @@ from ..graphic_utils import ListView
 class LibraryScreen(BaseScreen):
     def __init__(self, size, base_size, manager, fonts):
         BaseScreen.__init__(self, size, base_size, manager, fonts)
-        self.list_view = ListView((0, 0), (
-            self.size[0], self.size[1] -
-            self.base_size), self.base_size, self.fonts['base'])
+        self.list_view = ListView((0, 0), self.size, self.base_size, self.fonts['base'])
         self.directory_list = []
         self.current_directory = None
         self.library = None
@@ -40,6 +38,9 @@ class LibraryScreen(BaseScreen):
     def should_update(self):
         return self.list_view.should_update()
 
+    def find_update_rects(self, rects):
+        return self.list_view.find_update_rects(rects)
+
     def update(self, screen, update_type, rects):
         update_all = (update_type == BaseScreen.update_all)
         self.list_view.render(screen, update_all, rects)

mopidy_touchscreen/screens/main_screen.py

@@ -36,6 +36,7 @@ class MainScreen(BaseScreen):
         self.update_keys = []
         self.current_track_pos = 0
         self.track_duration = "00:00"
+        self.has_to_update_progress = False
         self.touch_text_manager = ScreenObjectsManager()
         current_track = self.core.playback.current_track.get()
         if current_track is None:
@@ -68,24 +69,37 @@ class MainScreen(BaseScreen):
         progress.set_value(self.core.playback.volume.get())
         self.progress_show = False
 
+
+
     def should_update(self):
         if len(self.update_keys) > 0:
+            if self.update_progress():
+                self.has_to_update_progress = True
             return True
         else:
             if self.progress_show:
-                track_pos_millis = self.core.playback.time_position.get()
-                new_track_pos = track_pos_millis / 1000
-                if new_track_pos != self.current_track_pos:
+                if self.update_progress():
+                    self.has_to_update_progress = True
                     return True
                 else:
                     return False
             else:
                 return False
 
+    def find_update_rects(self, rects):
+        for key in self.update_keys:
+            object = self.touch_text_manager.get_object(key)
+            rects.append(object.rect_in_pos)
+        if self.progress_show and self.has_to_update_progress :
+            object = self.touch_text_manager.get_touch_object("time_progress")
+            print object.rect_in_pos
+            rects.append(object.rect_in_pos)
+
     def update(self, screen, update_type, rects):
         if update_type == BaseScreen.update_all:
             screen.blit(self.top_bar, (0, 0))
-            self.update_progress(screen, rects)
+            self.update_progress()
+            self.has_to_update_progress = False
             self.touch_text_manager.render(screen)
             if self.image is not None:
                 screen.blit(self.image, (
@@ -95,17 +109,16 @@ class MainScreen(BaseScreen):
         if update_type == BaseScreen.update_partial \
                 and self.track is not None:
 
-            progress = self.update_progress(screen, rects)
-            if progress is not None:
-                progress.render(screen)
-                rects.append(progress.rect_in_pos)
+            if self.has_to_update_progress:
+                self.touch_text_manager.get_touch_object(
+                    "time_progress").render(screen)
+                self.has_to_update_progress = False
             for key in self.update_keys:
                 object = self.touch_text_manager.get_object(key)
                 object.update()
                 object.render(screen)
-                rects.append(object.rect_in_pos)
 
-    def update_progress(self, screen, rects):
+    def update_progress(self):
         if self.progress_show:
                 track_pos_millis = self.core.playback.time_position.get()
                 new_track_pos = track_pos_millis / 1000
@@ -119,25 +132,25 @@ class MainScreen(BaseScreen):
                         time.strftime('%M:%S', time.gmtime(
                             self.current_track_pos)) +
                         "/" + self.track_duration)
-                    return progress
-        return None
+                    return True
+        return False
 
     def track_started(self, track):
         self.update_keys = []
         self.image = None
-        x = self.size[1] - self.base_size * 3
+        x = self.size[1] - self.base_size * 2
         width = self.size[0] - self.base_size / 2 - x
 
         # Previous track button
         button = TouchAndTextItem(self.fonts['icon'], u"\ue61c",
-                                  (0, self.size[1] - self.base_size * 2), None)
+                                  (0, self.size[1] - self.base_size), None)
         self.touch_text_manager.set_touch_object("previous", button)
         size_1 = button.get_right_pos()
 
         size_2 = self.fonts['icon'].size(u"\ue61d")[0]
         button = TouchAndTextItem(self.fonts['icon'], u"\ue61d",
                                   (self.size[0] - size_2,
-                                   self.size[1] - self.base_size * 2),
+                                   self.size[1] - self.base_size),
                                   None)
         self.touch_text_manager.set_touch_object("next", button)
 
@@ -150,7 +163,7 @@ class MainScreen(BaseScreen):
                                    time.strftime('%M:%S', time.gmtime(
                                        0)) + "/" + time.strftime(
                                    '%M:%S', time.gmtime(0)),
-                                   (size_1, self.size[1] - self.base_size * 2),
+                                   (size_1, self.size[1] - self.base_size),
                                    (
                                    self.size[0] - size_1 - size_2,
                                    self.base_size),
@@ -333,7 +346,7 @@ class MainScreen(BaseScreen):
         self.touch_text_manager.set_object("artist_name", current)
 
     def load_image(self):
-        size = self.size[1] - self.base_size * 4
+        size = self.size[1] - self.base_size * 3
         image_original = pygame.image.load(
             self.get_cover_folder() +
             self.get_image_file_name())

mopidy_touchscreen/screens/menu_screen.py

@@ -11,7 +11,7 @@ class MenuScreen(BaseScreen):
         BaseScreen.__init__(self, size, base_size, manager, fonts)
         self.ip = None
         self.core = core
-        self.list = ListView((0, 0), (size[0], size[1]-base_size),
+        self.list = ListView((0, 0), size,
                              base_size, fonts['base'])
 
         self.list_items = ["Random", "Repeat", "Single", "Consume",
@@ -22,6 +22,10 @@ class MenuScreen(BaseScreen):
     def should_update(self):
         return self.list.should_update()
 
+    def find_update_rects(self, rects):
+        return self.list_view.find_update_rects(rects)
+
+
     def update(self, screen, update_type, rects):
         update_all = (update_type == BaseScreen.update_all)
         self.list.render(screen, update_all, rects)

mopidy_touchscreen/screens/playlist_screen.py

@@ -6,9 +6,7 @@ from ..graphic_utils import ListView
 class PlaylistScreen(BaseScreen):
     def __init__(self, size, base_size, manager, fonts):
         BaseScreen.__init__(self, size, base_size, manager, fonts)
-        self.list_view = ListView((0, 0), (
-            self.size[0], self.size[1] -
-            self.base_size), self.base_size,
+        self.list_view = ListView((0, 0), size, self.base_size,
             self.fonts['base'])
         self.playlists_strings = []
         self.playlists = []
@@ -20,6 +18,10 @@ class PlaylistScreen(BaseScreen):
     def should_update(self):
         return self.list_view.should_update()
 
+    def find_update_rects(self, rects):
+        return self.list_view.find_update_rects(rects)
+
+
     def update(self, screen, update_type, rects):
         update_all = (update_type == BaseScreen.update_all)
         self.list_view.render(screen, update_all, rects)

mopidy_touchscreen/screens/search_screen.py

@@ -17,7 +17,7 @@ class SearchScreen(BaseScreen):
         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'])
+            2*self.base_size), self.base_size, manager.fonts['base'])
         self.results_strings = []
         self.results = []
         self.screen_objects = ScreenObjectsManager()
@@ -76,6 +76,10 @@ class SearchScreen(BaseScreen):
     def should_update(self):
         return self.list_view.should_update()
 
+    def find_update_rects(self, rects):
+        return self.list_view.find_update_rects(rects)
+
+
     def update(self, screen, update_type, rects):
         screen.blit(self.top_bar, (0, 0))
         self.screen_objects.render(screen)

mopidy_touchscreen/screens/tracklist.py

@@ -10,9 +10,7 @@ class Tracklist(BaseScreen):
         self.size = size
         self.base_size = base_size
         self.manager = manager
-        self.list_view = ListView((0, 0), (
-            self.size[0], self.size[1] -
-            self.base_size), self.base_size, self.fonts['base'])
+        self.list_view = ListView((0, 0), size, self.base_size, self.fonts['base'])
         self.tracks = []
         self.tracks_strings = []
         self.update_list()
@@ -22,6 +20,10 @@ class Tracklist(BaseScreen):
     def should_update(self):
         return self.list_view.should_update()
 
+    def find_update_rects(self, rects):
+        return self.list_view.find_update_rects(rects)
+
+
     def update(self, screen, update_type, rects):
         update_all = (update_type == BaseScreen.update_all)
         self.list_view.render(screen, update_all, rects)