Arrows first working version

mopidy_touchscreen/screen_manager.py

@@ -154,42 +154,12 @@ class ScreenManager():
             if event.type == InputManager.click:
                 objects = self.screen_objects_manager.get_touch_objects_in_pos(
                     event.current_pos)
-                if objects is not None:
+                self.click_on_objects(objects, event)
-                    for key in objects:
+            elif event.type == InputManager.key and event.direction == InputManager.enter:
-                        if key == "volume":
+                objects = [self.screen_objects_manager.selected_key]
-                            manager = self.screen_objects_manager
+                self.click_on_objects(objects, event)
-                            volume = manager.get_touch_object(key)
-                            pos = event.current_pos
-                            value = volume.get_pos_value(pos)
-                            self.backend.tell(
-                                {'action': 'volume', 'value': value})
-                            self.volume_changed(value)
-                        elif key == "pause_play":
-                            if self.core.playback.state.get() == \
-                                    mopidy.core.PlaybackState.PLAYING:
-                                self.core.playback.pause()
-                            else:
-                                self.core.playback.play()
-                        elif key == "mute":
-                            mute = not self.core.playback.mute.get()
-                            self.core.playback.set_mute(mute)
-                            self.mute_changed(mute)
-                        elif key == "random":
-                            random = not self.core.tracklist.random.get()
-                            self.core.tracklist.set_random(random)
-                            self.options_changed()
-                        elif key == "repeat":
-                            self.core.tracklist.set_repeat(
-                                not self.core.tracklist.repeat.get())
-                        elif key == "single":
-                            self.core.tracklist.set_single(
-                                not self.core.tracklist.single.get())
-                        elif key == "internet":
-                            self.screens[4].check_connection()
-                        elif key[:-1] == "menu_":
-                            self.change_screen(int(key[-1:]))
             elif event.type == InputManager.key:
-                self.screen_objects_manager.change_selected((0,0), InputManager.down)
+                self.screen_objects_manager.change_selected(event.direction)
             self.screens[self.current_screen].touch_event(event)
 
     def volume_changed(self, volume):
@@ -209,6 +179,45 @@ class ScreenManager():
         self.screen_objects_manager.get_touch_object("volume").set_value(
             volume)
 
+    def click_on_objects(self, objects, event):
+        if objects is not None:
+            for key in objects:
+                if key == "volume":
+                    self.change_volume(event)
+                elif key == "pause_play":
+                    if self.core.playback.state.get() == \
+                            mopidy.core.PlaybackState.PLAYING:
+                        self.core.playback.pause()
+                    else:
+                        self.core.playback.play()
+                elif key == "mute":
+                    mute = not self.core.playback.mute.get()
+                    self.core.playback.set_mute(mute)
+                    self.mute_changed(mute)
+                elif key == "random":
+                    random = not self.core.tracklist.random.get()
+                    self.core.tracklist.set_random(random)
+                    self.options_changed()
+                elif key == "repeat":
+                    self.core.tracklist.set_repeat(
+                        not self.core.tracklist.repeat.get())
+                elif key == "single":
+                    self.core.tracklist.set_single(
+                        not self.core.tracklist.single.get())
+                elif key == "internet":
+                    self.screens[4].check_connection()
+                elif key[:-1] == "menu_":
+                    self.change_screen(int(key[-1:]))
+
+    def change_volume(self,event):
+        manager = self.screen_objects_manager
+        volume = manager.get_touch_object("volume")
+        pos = event.current_pos
+        value = volume.get_pos_value(pos)
+        self.backend.tell(
+            {'action': 'volume', 'value': value})
+        self.volume_changed(value)
+
     def playback_state_changed(self, old_state, new_state):
         if new_state == mopidy.core.PlaybackState.PLAYING:
             self.screen_objects_manager.get_touch_object(

mopidy_touchscreen/screen_objects.py

@@ -14,6 +14,7 @@ class ScreenObjectsManager():
         self.touch_objects = {}
         self.text_objects = {}
         self.selected = None
+        self.selected_key = None
 
     def set_object(self, key, add_object):
         self.text_objects[key] = add_object
@@ -57,28 +58,135 @@ class ScreenObjectsManager():
         if key is not None:
             self.selected = self.touch_objects[key]
             self.selected.set_selected(True)
+            self.selected_key = key
+        else:
+            self.selected = None
+            self.selected.set_selected(False)
+            self.selected_key = None
 
-    def change_selected(self, pos, direction):
+    def change_selected(self, direction):
-        if direction == InputManager.up:
+        pos = self.selected.pos
-            pass
+        if direction == InputManager.right:
+            bests = self.find_nearest_objects(self.find_in_quadrant(False, True), True)
+            best_key = self.find_best_object(bests, False, True)
+        elif direction == InputManager.left:
+            bests = self.find_nearest_objects(self.find_in_quadrant(False, False), True)
+            best_key = self.find_best_object(bests, False, False)
         elif direction == InputManager.down:
-            best = None
+            bests = self.find_nearest_objects(self.find_in_quadrant(True, True), False)
-            for key in self.touch_objects:
+            best_key = self.find_best_object(bests, True, True)
-                if self.touch_objects[key].pos[1] > pos[1]:
+        elif direction == InputManager.up:
-                    if best is None:
+            bests = self.find_nearest_objects(self.find_in_quadrant(True, False), False)
-                        best = self.touch_objects[key].pos[1]
+            best_key = self.find_best_object(bests, True, False)
-                    elif best > self.touch_objects[key].pos[1]:
+        if best_key is None:
-                        best = self.touch_objects[key].pos[1]
+            return False
-            self.set_selected(self.find_best(pos, True, best))
+        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 = self.selected.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 = self.selected.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 = self.selected.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
+
 
-    def find_best(self, pos, horizontal, best):
-        if horizontal:
-            keys = []
-            for key in self.touch_objects:
-                if self.touch_objects[key].pos[1] == best:
-                    keys.append(key)
-            logger.error(keys)
-            return keys[0]