From e98e198224c3696fb1d35bd68538da3d9cc9cbc6 Mon Sep 17 00:00:00 2001 From: Ander <9and3r@gmail.com> Date: Tue, 19 May 2015 17:04:47 +0200 Subject: [PATCH] Lower CPU usage Screen will not be always updated --- mopidy_touchscreen/graphic_utils/__init__.py | 2 +- .../graphic_utils/background_manager.py | 54 +++++++++ .../graphic_utils/dynamic_background.py | 108 ------------------ mopidy_touchscreen/graphic_utils/list_view.py | 27 ++++- .../graphic_utils/screen_objects.py | 6 +- mopidy_touchscreen/input/input_manager.py | 1 - mopidy_touchscreen/screen_manager.py | 67 +++++++++-- mopidy_touchscreen/screens/__init__.py | 1 + mopidy_touchscreen/screens/base_screen.py | 9 +- mopidy_touchscreen/screens/keyboard_screen.py | 107 ++++++++++++++--- mopidy_touchscreen/screens/library_screen.py | 8 +- mopidy_touchscreen/screens/main_screen.py | 71 +++++++++--- mopidy_touchscreen/screens/menu_screen.py | 8 +- mopidy_touchscreen/screens/playlist_screen.py | 8 +- mopidy_touchscreen/screens/search_screen.py | 8 +- mopidy_touchscreen/screens/tracklist.py | 8 +- mopidy_touchscreen/touch_screen.py | 6 +- 17 files changed, 325 insertions(+), 174 deletions(-) create mode 100644 mopidy_touchscreen/graphic_utils/background_manager.py delete mode 100644 mopidy_touchscreen/graphic_utils/dynamic_background.py diff --git a/mopidy_touchscreen/graphic_utils/__init__.py b/mopidy_touchscreen/graphic_utils/__init__.py index fe01797..ca52232 100644 --- a/mopidy_touchscreen/graphic_utils/__init__.py +++ b/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 * diff --git a/mopidy_touchscreen/graphic_utils/background_manager.py b/mopidy_touchscreen/graphic_utils/background_manager.py new file mode 100644 index 0000000..f07e556 --- /dev/null +++ b/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 diff --git a/mopidy_touchscreen/graphic_utils/dynamic_background.py b/mopidy_touchscreen/graphic_utils/dynamic_background.py deleted file mode 100644 index 55fa122..0000000 --- a/mopidy_touchscreen/graphic_utils/dynamic_background.py +++ /dev/null @@ -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 diff --git a/mopidy_touchscreen/graphic_utils/list_view.py b/mopidy_touchscreen/graphic_utils/list_view.py index 22fe9d1..f079794 100644 --- a/mopidy_touchscreen/graphic_utils/list_view.py +++ b/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( diff --git a/mopidy_touchscreen/graphic_utils/screen_objects.py b/mopidy_touchscreen/graphic_utils/screen_objects.py index e3b5c59..8398337 100644 --- a/mopidy_touchscreen/graphic_utils/screen_objects.py +++ b/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) diff --git a/mopidy_touchscreen/input/input_manager.py b/mopidy_touchscreen/input/input_manager.py index 23375c5..135a329 100644 --- a/mopidy_touchscreen/input/input_manager.py +++ b/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: diff --git a/mopidy_touchscreen/screen_manager.py b/mopidy_touchscreen/screen_manager.py index f19ce07..24f51e0 100644 --- a/mopidy_touchscreen/screen_manager.py +++ b/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 diff --git a/mopidy_touchscreen/screens/__init__.py b/mopidy_touchscreen/screens/__init__.py index 6b9a9d9..326b14e 100644 --- a/mopidy_touchscreen/screens/__init__.py +++ b/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 diff --git a/mopidy_touchscreen/screens/base_screen.py b/mopidy_touchscreen/screens/base_screen.py index 58149a1..a3d72a8 100644 --- a/mopidy_touchscreen/screens/base_screen.py +++ b/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 diff --git a/mopidy_touchscreen/screens/keyboard_screen.py b/mopidy_touchscreen/screens/keyboard_screen.py index b25b204..3ff7a77 100644 --- a/mopidy_touchscreen/screens/keyboard_screen.py +++ b/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) diff --git a/mopidy_touchscreen/screens/library_screen.py b/mopidy_touchscreen/screens/library_screen.py index 0812319..f1d23f4 100644 --- a/mopidy_touchscreen/screens/library_screen.py +++ b/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) diff --git a/mopidy_touchscreen/screens/main_screen.py b/mopidy_touchscreen/screens/main_screen.py index 6dc077e..c7f2436 100644 --- a/mopidy_touchscreen/screens/main_screen.py +++ b/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: diff --git a/mopidy_touchscreen/screens/menu_screen.py b/mopidy_touchscreen/screens/menu_screen.py index 9aae541..be60710 100644 --- a/mopidy_touchscreen/screens/menu_screen.py +++ b/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) diff --git a/mopidy_touchscreen/screens/playlist_screen.py b/mopidy_touchscreen/screens/playlist_screen.py index 1068d51..70957f1 100644 --- a/mopidy_touchscreen/screens/playlist_screen.py +++ b/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 diff --git a/mopidy_touchscreen/screens/search_screen.py b/mopidy_touchscreen/screens/search_screen.py index 5eee51f..02b59ee 100644 --- a/mopidy_touchscreen/screens/search_screen.py +++ b/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: diff --git a/mopidy_touchscreen/screens/tracklist.py b/mopidy_touchscreen/screens/tracklist.py index c94d9a1..d44660a 100644 --- a/mopidy_touchscreen/screens/tracklist.py +++ b/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() diff --git a/mopidy_touchscreen/touch_screen.py b/mopidy_touchscreen/touch_screen.py index aa536fd..cdfedbf 100644 --- a/mopidy_touchscreen/touch_screen.py +++ b/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")