Merge branch 'background-cover' into develop

Conflicts:
	mopidy_touchscreen/graphic_utils/dynamic_background.py
	mopidy_touchscreen/graphic_utils/screen_objects.py
	mopidy_touchscreen/screen_manager.py
	mopidy_touchscreen/screens/main_screen.py

mopidy_touchscreen/graphic_utils/dynamic_background.py

@@ -1,35 +1,44 @@
 import random
 
+import pygame
+
 
 change_speed = 2
 
 
 class DynamicBackground():
-    def __init__(self):
+
+    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, surfaces):
-        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
-        for surface in surfaces:
-            surface.fill(self.current)
+    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):
+    def set_target_color(self, color, image):
         if color is not None:
             self.auto_mode = False
             self.target_current_same = False
@@ -39,6 +48,18 @@ class DynamicBackground():
             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
@@ -72,3 +93,17 @@ def get_valid_color():
         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/screen_objects.py

@@ -91,6 +91,7 @@ class TextItem(BaseItem):
         self.text = text
         self.color = (255, 255, 255)
         self.box = self.font.render(text, True, self.color)
+        self.box = self.box.convert_alpha()
         if size is not None:
             if size[1] == -1:
                 height = self.font.size(text)[1]
@@ -174,9 +175,11 @@ class TouchObject(BaseItem):
         self.active = False
         self.selected = False
         self.selected_box = pygame.Surface(size, pygame.SRCALPHA)
+        self.selected_box = self.selected_box.convert_alpha()
         self.selected_box.fill((0, 0, 0, 128))
-        self.selected_box_rectangle = pygame.Surface(size,
-                                                     pygame.SRCALPHA)
+        self.selected_box_rectangle = pygame.Surface(size, pygame.SRCALPHA)
+        self.selected_box_rectangle = \
+            self.selected_box_rectangle.convert_alpha()
         pygame.draw.rect(self.selected_box_rectangle, (255, 255, 255),
                          self.selected_box_rectangle.get_rect(),
                          size[1]/10+1)
@@ -242,7 +245,8 @@ class Progressbar(TouchObject):
         self.max = max_value
         self.back_color = (0, 0, 0, 128)
         self.main_color = (0, 150, 255)
-        self.surface = pygame.Surface(self.size, pygame.SRCALPHA)
+        self.surface = pygame.Surface(self.size, pygame.SRCALPHA)\
+            .convert_alpha()
         self.surface.fill(self.back_color)
         self.value_text = value_text
         if value_text:
@@ -259,8 +263,8 @@ class Progressbar(TouchObject):
                 2, self.text.pos[1])
 
         # Rectangle
-        self.rectangle = pygame.Surface(size,
-                                                     pygame.SRCALPHA)
+        self.rectangle = pygame.Surface(size, pygame.SRCALPHA)\
+            .convert_alpha()
         pygame.draw.rect(self.rectangle, (255, 255, 255),
                          self.rectangle.get_rect(),
                          size[1]/20+1)
@@ -301,7 +305,8 @@ class ScrollBar(TouchObject):
         self.max = max_value
         self.items_on_screen = items_on_screen
         self.current_item = 0
-        self.back_bar = pygame.Surface(self.size, pygame.SRCALPHA)
+        self.back_bar = pygame.Surface(self.size, pygame.SRCALPHA)\
+            .convert_alpha()
         self.back_bar.fill((255, 255, 255, 128))
         self.bar_pos = 0
         if self.max < 1:
@@ -310,7 +315,7 @@ class ScrollBar(TouchObject):
             self.bar_size = math.ceil(
                 float(self.items_on_screen) / float(self.max) * float(
                     self.size[1]))
-        self.bar = pygame.Surface((self.size[0], self.bar_size))
+        self.bar = pygame.Surface((self.size[0], self.bar_size)).convert()
         self.bar.fill((255, 255, 255))
 
     def render(self, surface):

mopidy_touchscreen/screen_manager.py

@@ -28,6 +28,7 @@ class ScreenManager():
         self.core = core
         self.cache = cache
         self.fonts = {}
+        self.background = None
         self.current_screen = library_index
 
         # Init variables in init
@@ -37,7 +38,10 @@ class ScreenManager():
         self.track = None
         self.input_manager = InputManager(size)
         self.down_bar_objects = ScreenObjectsManager()
+<<<<<<< HEAD
         self.down_bar_solid = None
+=======
+>>>>>>> background-cover
         self.down_bar = None
 
         self.init_manager(size)
@@ -45,7 +49,6 @@ class ScreenManager():
     def init_manager(self, size):
         self.size = size
         self.background = DynamicBackground(self.size)
-        self.current_screen = 0
         self.base_size = self.size[1] / 8
         font = resource_filename(
             Requirement.parse("mopidy-touchscreen"),
@@ -132,11 +135,16 @@ class ScreenManager():
         self.change_screen(self.current_screen)
 
     def update(self):
+<<<<<<< HEAD
         surface = pygame.Surface(self.size)
         self.background.draw_background([surface,
                                          self.down_bar_solid])
         self.screens[self.current_screen].update(surface)
         surface.blit(self.down_bar_solid, (0, self.base_size * 7))
+=======
+        surface = self.background.draw_background()
+        self.screens[self.current_screen].update(surface)
+>>>>>>> background-cover
         surface.blit(self.down_bar, (0, self.base_size * 7))
         self.down_bar_objects.render(surface)
         return surface

mopidy_touchscreen/screens/main_screen.py

@@ -255,7 +255,7 @@ class MainScreen(BaseScreen):
                                                      current)
 
     def track_playback_ended(self, tl_track, time_position):
-        self.background.set_target_color(None)
+        self.background.set_target_color(None, None)
         self.image = None
         self.track_duration = "00:00"
 
@@ -284,11 +284,13 @@ class MainScreen(BaseScreen):
 
     def load_image(self):
         size = self.base_size * 4
-        image = pygame.transform.scale(pygame.image.load(
+        image_original = 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_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
 
     def touch_event(self, event):

mopidy_touchscreen/screens/playlist_screen.py

@@ -12,7 +12,6 @@ class PlaylistScreen(BaseScreen):
             self.fonts['base'])
         self.playlists_strings = []
         self.playlists = []
-        self.playlists_loaded()
         self.selected_playlist = None
         self.playlist_tracks = []
         self.playlist_tracks_strings = []