Cleanup

Remove unused methods

mopidy_touchscreen/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import unicode_literals
-
 import logging
 import os
+
 from mopidy import config, ext
 
 from .touch_screen import TouchScreen
@@ -9,9 +9,6 @@ from .touch_screen import TouchScreen
 
 __version__ = '0.3.2'
 
-# TODO: If you need to log, use loggers named after the current Python module
-logger = logging.getLogger(__name__)
-
 
 class Extension(ext.Extension):
     dist_name = 'Mopidy-Touchscreen'

mopidy_touchscreen/dynamic_background.py

@@ -43,12 +43,13 @@ class DynamicBackground():
 # 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):
+        for x in range(0, 3):
             new_color[x] = color[x] - rest
         return new_color
     else:

mopidy_touchscreen/gpio_inpput_manager.py

@@ -1,7 +1,7 @@
 import logging
-import pygame
 
 import RPi.GPIO as GPIO
+import pygame
 
 
 logger = logging.getLogger(__name__)
@@ -92,8 +92,3 @@ def enter(channel):
     dict['key'] = pygame.K_RETURN
     event = pygame.event.Event(type, dict)
     pygame.event.post(event)
-
-
-
-
-

mopidy_touchscreen/input_manager.py

@@ -93,10 +93,10 @@ class InputManager():
 
     def mouse_up(self, event):
         self.up_pos = event.pos
-        if abs(self.down_pos[0] - self.up_pos[
+        if abs(self.down_pos[0] -
-            0]) < self.max_move_margin:
+                self.up_pos[0]) < self.max_move_margin:
-            if abs(self.down_pos[1] - self.up_pos[
+            if abs(self.down_pos[1] -
-                1]) < self.max_move_margin:
+                    self.up_pos[1]) < self.max_move_margin:
                 if time.time() - InputManager.long_click_min_time > \
                         self.down_time:
                     return InputEvent(InputManager.long_click,
@@ -106,8 +106,8 @@ class InputManager():
                     return InputEvent(InputManager.click,
                                       self.down_pos,
                                       self.up_pos, None, None)
-            elif abs(self.down_pos[1] - self.up_pos[
+            elif abs(self.down_pos[1] - self.up_pos[1])\
-                1]) > self.min_swipe_move:
+                    > self.min_swipe_move:
                 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:

mopidy_touchscreen/library_screen.py

@@ -1,29 +1,21 @@
-import logging
 import mopidy.models
 
-from .list_view import ListView
-from .input_manager import InputManager
 from .base_screen import BaseScreen
-
+from .list_view import ListView
-logger = logging.getLogger(__name__)
 
 
 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.size[0], self.size[1] -
-                                  self.base_size,
+            self.base_size), self.base_size, self.fonts['base'])
-                                  self.fonts['base'])
         self.directory_list = []
         self.current_directory = None
         self.library = None
         self.library_strings = None
         self.browse_uri(None)
 
-    def get_dirty_area(self):
-        return self.list_view.get_dirty_area()
-
     def go_inside_directory(self, uri):
         self.directory_list.append(self.current_directory)
         self.current_directory = uri
@@ -56,23 +48,23 @@ class LibraryScreen(BaseScreen):
                 else:
                     if self.library[clicked - 1].type\
                             == mopidy.models.Ref.TRACK:
-                        self.play_uri(self.current_directory, clicked-1)
+                        self.play_uri(clicked-1)
                     else:
                         self.go_inside_directory(
                             self.library[clicked - 1].uri)
             else:
                 self.go_inside_directory(self.library[clicked].uri)
 
-    def play_uri(self, uri, track_pos):
+    def play_uri(self, track_pos):
         self.manager.core.tracklist.clear()
         tracks = []
         for item in self.library:
             if item.type == mopidy.models.Ref.TRACK:
-                tracks.append(self.manager.core.library.lookup(item.uri).get()[0])
+                tracks.append(self.manager.core.library.lookup(
+                    item.uri).get()[0])
             else:
                 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])
-

mopidy_touchscreen/list_view.py

@@ -1,8 +1,8 @@
 import logging
 
+from .input_manager import InputManager
 from .screen_objects import ScreenObjectsManager, ScrollBar, \
     TouchAndTextItem
-from .input_manager import InputManager
 
 logger = logging.getLogger(__name__)
 
@@ -61,8 +61,8 @@ class ListView():
             width = self.size[0]
         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),
+                self.pos[0],
-                                    (width, -1))
+                self.pos[1] + self.base_size * z), (width, -1))
             self.screen_objects.set_touch_object(str(i), item)
             i += 1
             z += 1
@@ -79,7 +79,8 @@ class ListView():
             if objects is not None:
                 for key in objects:
                     if key == "scrollbar":
-                        direction = self.screen_objects.get_touch_object(
+                        direction = \
+                            self.screen_objects.get_touch_object(
                                 key).touch(touch_event.current_pos)
                         if direction != 0:
                             self.move_to(direction)

mopidy_touchscreen/main_screen.py

@@ -10,9 +10,9 @@ from threading import Thread
 import pygame
 
 from .base_screen import BaseScreen
+from .input_manager import InputManager
 from .screen_objects import (Progressbar, ScreenObjectsManager,
                              TouchAndTextItem)
-from .input_manager import InputManager
 
 
 logger = logging.getLogger(__name__)

mopidy_touchscreen/menu_screen.py

@@ -2,9 +2,9 @@ import os
 import socket
 import mopidy
 
-from .screen_objects import ScreenObjectsManager, TouchAndTextItem
-from .input_manager import InputManager
 from .base_screen import BaseScreen
+from .input_manager import InputManager
+from .screen_objects import ScreenObjectsManager, TouchAndTextItem
 
 
 class MenuScreen(BaseScreen):

mopidy_touchscreen/playlist_screen.py

@@ -42,7 +42,7 @@ class PlaylistScreen(BaseScreen):
             if self.selected_playlist is None:
                 self.playlist_selected(self.playlists[clicked])
             else:
-                if clicked==0:
+                if clicked == 0:
                     self.selected_playlist = None
                     self.list_view.set_list(self.playlists_strings)
                 else:
@@ -50,6 +50,6 @@ class PlaylistScreen(BaseScreen):
                     self.manager.core.tracklist.add(
                         self.playlist_tracks)
                     self.manager.core.playback.play(
-                        tl_track=
+                        tl_track=self.manager.core.
-                        self.manager.core.tracklist.tl_tracks.get()
+                        tracklist.tl_tracks.get()
                         [clicked-1])

mopidy_touchscreen/screen_manager.py

@@ -3,16 +3,18 @@ import traceback
 import pygame
 from pkg_resources import Requirement, resource_filename
 
-from .search_screen import SearchScreen
+from .dynamic_background import DynamicBackground
+from .input_manager import InputManager
 from .library_screen import LibraryScreen
 from .main_screen import MainScreen
 from .menu_screen import MenuScreen
 from .playlist_screen import PlaylistScreen
+from .search_screen import SearchScreen
 from .screen_objects import ScreenObjectsManager, \
     TouchAndTextItem
-from .input_manager import InputManager
+
 from .tracklist import Tracklist
-from .dynamic_background import DynamicBackground
+
 
 logger = logging.getLogger(__name__)
 

mopidy_touchscreen/screen_objects.py

@@ -1,5 +1,6 @@
 import logging
 import math
+
 import pygame
 
 from .input_manager import InputManager
@@ -66,135 +67,6 @@ class ScreenObjectsManager():
             self.selected = None
             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:
-            bests = self.find_nearest_objects(
-                self.find_in_quadrant(False, True, pos), True, pos)
-            best_key = self.find_best_object(bests, False, True, pos)
-        elif direction == InputManager.left:
-            bests = self.find_nearest_objects(
-                self.find_in_quadrant(False, False, pos), True, pos)
-            best_key = self.find_best_object(bests, False, False, pos)
-        elif direction == InputManager.down:
-            bests = self.find_nearest_objects(
-                self.find_in_quadrant(True, True, pos), False, pos)
-            best_key = self.find_best_object(bests, True, True, pos)
-        elif direction == InputManager.up:
-            bests = self.find_nearest_objects(
-                self.find_in_quadrant(True, False, pos), False, pos)
-            best_key = self.find_best_object(bests, True, False, pos)
-        if best_key is None:
-            return False
-        else:
-            self.set_selected(best_key)
-            return True
-
-    # Find touch objects on specified quadrant
-    # The quadrant is the normal math one with x and y
-    # x is positive on the bottom as pygame x
-    # The quadrant origin (0,0) is the selected pos
-    def find_in_quadrant(self, vertical, positive, pos):
-        objects = {}
-        if vertical:
-            if positive:
-                for key in self.touch_objects:
-                    current = self.touch_objects[key]
-                    if current.pos[1] > pos[1]:
-                        objects[key] = current
-            else:
-                for key in self.touch_objects:
-                    current = self.touch_objects[key]
-                    if current.pos[1] < pos[1]:
-                        objects[key] = current
-        else:
-            if positive:
-                for key in self.touch_objects:
-                    current = self.touch_objects[key]
-                    if current.pos[0] > pos[0]:
-                        objects[key] = current
-            else:
-                for key in self.touch_objects:
-                    current = self.touch_objects[key]
-                    if current.pos[0] < pos[0]:
-                        objects[key] = current
-        return objects
-
-    # Find the objects that are nearest
-    def find_nearest_objects(self, objects, vertical, pos):
-        best_pos = None
-        min_value = None
-        best_objects = {}
-        if vertical:
-            for key in objects:
-                if min_value is None:
-                    best_pos = objects[key].pos[1]
-                    min_value = abs(objects[key].pos[1] - pos[1])
-                elif abs(objects[key].pos[1] - pos[1]) < min_value:
-                    min_value = abs(objects[key].pos[1] - pos[1])
-                    best_pos = objects[key].pos[1]
-            for key in objects:
-                if objects[key].pos[1] == best_pos:
-                    best_objects[key] = objects[key]
-            return best_objects
-        else:
-            for key in objects:
-                if min_value is None:
-                    best_pos = objects[key].pos[0]
-                    min_value = abs(objects[key].pos[0] - pos[0])
-                elif abs(objects[key].pos[0] - pos[0]) < min_value:
-                    min_value = abs(objects[key].pos[0] - pos[0])
-                    best_pos = objects[key].pos[0]
-            for key in objects:
-                if objects[key].pos[0] == best_pos:
-                    best_objects[key] = objects[key]
-            return best_objects
-
-    def find_best_object(self, objects, vertical, positive, pos):
-        best_key = None
-        best_pos = None
-        if vertical:
-            if positive:
-                for key in objects:
-                    if best_pos is None:
-                        best_pos = objects[key].pos[1]
-                        best_key = key
-                    elif objects[key].pos[1] >= pos[1] and \
-                                    objects[key].pos[1] < best_pos:
-                        best_pos = objects[key].pos[1]
-                        best_key = key
-            else:
-                for key in objects:
-                    if best_pos is None:
-                        best_pos = objects[key].pos[1]
-                        best_key = key
-                    elif objects[key].pos[1] <= pos[1] and \
-                                    objects[key].pos[1] > best_pos:
-                        best_pos = objects[key].pos[1]
-                        best_key = key
-        else:
-            if positive:
-                for key in objects:
-                    if best_pos is None:
-                        best_pos = objects[key].pos[0]
-                        best_key = key
-                    elif objects[key].pos[0] >= pos[0] and \
-                                    objects[key].pos[0] < best_pos:
-                        best_pos = objects[key].pos[0]
-                        best_key = key
-            else:
-                for key in objects:
-                    if best_pos is None:
-                        best_pos = objects[key].pos[0]
-                        best_key = key
-                    elif objects[key].pos[0] <= pos[0] and \
-                                    objects[key].pos[0] > best_pos:
-                        best_pos = objects[key].pos[0]
-                        best_key = key
-        return best_key
-
 
 class BaseItem():
     def __init__(self, pos, size):
@@ -250,7 +122,7 @@ class TextItem(BaseItem):
         self.center = center
         if self.center:
             if self.fit_horizontal:
-                self.margin = (self.size[0]-
+                self.margin = (self.size[0] -
                                self.box.get_rect().width)/2
 
     def update(self):
@@ -259,8 +131,9 @@ class TextItem(BaseItem):
             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_2 = \
-                                  - self.step + self.scroll_white_gap
+                        self.box.get_rect().width - \
+                        self.step + self.scroll_white_gap
             else:
                 self.step_2 -= TextItem.scroll_speed
                 if self.step_2 < 0:
@@ -272,7 +145,8 @@ class TextItem(BaseItem):
 
     def render(self, surface):
         if self.fit_horizontal:
-            surface.blit(self.box, ((self.pos[0] + self.margin), self.pos[1]), area=self.rect)
+            surface.blit(
+                self.box, ((self.pos[0] + self.margin), self.pos[1]), area=self.rect)
         else:
             surface.blit(self.box, self.pos,
                          area=pygame.Rect(self.step, 0, self.size[0],
@@ -280,7 +154,9 @@ class TextItem(BaseItem):
             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,
+                             area=pygame.Rect(0, 0,
+                                              self.size[0] -
+                                              self.step_2,
                                               self.size[1]))
 
     def set_text(self, text, change_size):

mopidy_touchscreen/search_screen.py

@@ -1,14 +1,11 @@
 from .list_view import ListView
-import logging
 
 import pygame
 
-from .screen_objects import Progressbar, ScreenObjectsManager, \
-    TouchAndTextItem, TextItem
 from .base_screen import BaseScreen
 from .input_manager import InputManager
-
+from .screen_objects import ScreenObjectsManager, \
-logger = logging.getLogger(__name__)
+    TouchAndTextItem, TextItem
 
 
 mode_track_name = 0

mopidy_touchscreen/touch_screen.py

@@ -1,7 +1,8 @@
 import logging
-import traceback
-from threading import Thread
 import os
+from threading import Thread
+import traceback
+
 import pygame
 import pykka
 import mopidy
@@ -28,7 +29,8 @@ class TouchScreen(pykka.ThreadingActor, core.CoreListener):
             'sdl_mousdrv']
         os.environ["SDL_MOUSEDEV"] = config['touchscreen'][
             'sdl_mousedev']
-        os.environ["SDL_AUDIODRIVER"] = config['touchscreen']['sdl_audiodriver']
+        os.environ["SDL_AUDIODRIVER"] = \
+            config['touchscreen']['sdl_audiodriver']
         os.environ["SDL_PATH_DSP"] = config['touchscreen']['sdl_path_dsp']
         pygame.init()
         pygame.display.set_caption("Mopidy-Touchscreen")
@@ -38,7 +40,6 @@ class TouchScreen(pykka.ThreadingActor, core.CoreListener):
                                             self.core,
                                             self.cache_dir)
 
-
         # Raspberry pi GPIO
         self.gpio = config['touchscreen']['gpio']
         if self.gpio:

mopidy_touchscreen/tracklist.py

@@ -1,6 +1,6 @@
+from .base_screen import BaseScreen
 from .list_view import ListView
 from .main_screen import MainScreen
-from .base_screen import BaseScreen
 
 
 class Tracklist(BaseScreen):