Febbweiss/mopidy-touchscreen
1
0
Fork 0
mirror of https://github.com/Febbweiss/mopidy-touchscreen.git synced 2026-03-04 22:25:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

Code fixes

Browse Source 
Do not use backend anymore
This commit is contained in:
Ander
2014-11-20 10:56:45 +01:00
parent 9448674301
commit d8839a5559
15 changed files with 2056 additions and 1935 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
mopidy_touchscreen/__init__.py
View File

@@ -2,11 +2,9 @@ from __future__ import unicode_literals
import logging
import os
from mopidy import config, ext
from .touch_screen import TouchScreen
from .touch_screen_backend import TouchScreenBackend
__version__ = '0.2.2'
@@ -21,7 +19,8 @@ class Extension(ext.Extension):
version = __version__
def get_default_config(self):
conf_file = os.path.join(os.path.dirname(__file__), 'ext.conf')
conf_file = os.path.join(os.path.dirname(__file__),
'ext.conf')
return config.read(conf_file)
def get_config_schema(self):
@@ -37,13 +36,10 @@ class Extension(ext.Extension):
schema['gpio_up'] = config.Integer()
schema['gpio_down'] = config.Integer()
schema['gpio_enter'] = config.Integer()
schema['sdl_fbdev'] = config.String()
schema['sdl_mousdrv'] = config.String()
schema['sdl_mousedev'] = config.String()
schema['sdl_fbdev'] = config.String()
schema['sdl_mousdrv'] = config.String()
schema['sdl_mousedev'] = config.String()
return schema
def setup(self, registry):
registry.add('frontend', TouchScreen)
# Backend used for controling volume
registry.add('backend', TouchScreenBackend)

1286
mopidy_touchscreen/fonts/icomoon/demo.html
View File

File diff suppressed because it is too large Load Diff

2138
mopidy_touchscreen/fonts/icomoon/selection.json
View File

File diff suppressed because it is too large Load Diff

6
mopidy_touchscreen/gpio_inpput_manager.py
View File

@@ -18,7 +18,8 @@ class GPIOManager():
# Right Button
GPIO.setup(pins['right'], GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.add_event_detect(pins['right'], GPIO.BOTH, callback=right,
GPIO.add_event_detect(pins['right'], GPIO.BOTH,
callback=right,
bouncetime=30)
# Up Button
@@ -33,7 +34,8 @@ class GPIOManager():
# Enter Button
GPIO.setup(pins['enter'], GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.add_event_detect(pins['enter'], GPIO.BOTH, callback=right,
GPIO.add_event_detect(pins['enter'], GPIO.BOTH,
callback=right,
bouncetime=30)

39
mopidy_touchscreen/input_manager.py
View File

@@ -34,19 +34,24 @@ class InputManager():
if event.type == pygame.MOUSEBUTTONUP:
if event.button == 4:
touch_event = InputEvent(InputManager.swipe, self.down_pos,
self.up_pos, True, InputManager.up)
touch_event = InputEvent(InputManager.swipe,
self.down_pos,
self.up_pos, True,
InputManager.up)
return touch_event
elif event.button == 5:
touch_event = InputEvent(InputManager.swipe, self.down_pos,
self.up_pos, True, InputManager.down)
touch_event = InputEvent(InputManager.swipe,
self.down_pos,
self.up_pos, True,
InputManager.down)
return touch_event
elif event.button == 1 and self.down_button == 1:
touch_event = self.mouse_up(event)
return touch_event
elif event.button == 3 and self.down_button == 3:
touch_event = InputEvent(InputManager.long_click,
self.down_pos, self.up_pos, None, None)
self.down_pos, self.up_pos,
None, None)
return touch_event
else:
return None
@@ -78,7 +83,8 @@ class InputManager():
else:
return None
if direction is not None:
return InputEvent(InputManager.key, None, None, None, direction)
return InputEvent(InputManager.key, None, None, None,
direction)
def mouse_down(self, event):
self.down_pos = event.pos
@@ -87,26 +93,33 @@ class InputManager():
def mouse_up(self, event):
self.up_pos = event.pos
if abs(self.down_pos[0] - self.up_pos[0]) < self.max_move_margin:
if abs(self.down_pos[1] - self.up_pos[1]) < self.max_move_margin:
if abs(self.down_pos[0] - self.up_pos[
0]) < self.max_move_margin:
if abs(self.down_pos[1] - self.up_pos[
1]) < self.max_move_margin:
if time.time() - InputManager.long_click_min_time > \
self.down_time:
return InputEvent(InputManager.long_click, self.down_pos,
return InputEvent(InputManager.long_click,
self.down_pos,
self.up_pos, None, None)
else:
return InputEvent(InputManager.click, self.down_pos,
return InputEvent(InputManager.click,
self.down_pos,
self.up_pos, None, None)
elif abs(self.down_pos[1] - self.up_pos[1]) > self.min_swipe_move:
elif abs(self.down_pos[1] - self.up_pos[
1]) > 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:
if abs(self.down_pos[0] - self.up_pos[0]) > self.min_swipe_move:
if abs(self.down_pos[0] - self.up_pos[
0]) > self.min_swipe_move:
return InputEvent(InputManager.swipe, self.down_pos,
self.up_pos, False, None)
class InputEvent():
def __init__(self, event_type, down_pos, current_pos, vertical, direction):
def __init__(self, event_type, down_pos, current_pos, vertical,
direction):
self.type = event_type
self.down_pos = down_pos
self.current_pos = current_pos

22
mopidy_touchscreen/library_screen.py
View File

@@ -1,5 +1,4 @@
import logging
import mopidy.models
from .list_view import ListView
@@ -15,7 +14,8 @@ class LibraryScreen():
self.manager = manager
self.list_view = ListView((0, self.base_size), (
self.size[0], self.size[1] - 2 * self.base_size),
self.base_size, manager.fonts['base'])
self.base_size,
manager.fonts['base'])
self.directory_list = []
self.current_directory = None
self.library = None
@@ -23,7 +23,7 @@ class LibraryScreen():
self.lookup_uri(None)
def get_dirty_area(self):
return self.list_view.get_dirty_area()
return self.list_view.get_dirty_area()
def go_inside_directory(self, uri):
self.directory_list.append(self.current_directory)
@@ -46,7 +46,7 @@ class LibraryScreen():
self.lookup_uri(directory)
def update(self, screen, update_all):
self.list_view.render(screen)
self.list_view.render(screen)
def touch_event(self, touch_event):
clicked = self.list_view.touch_event(touch_event)
@@ -56,7 +56,8 @@ class LibraryScreen():
if clicked == 0:
self.go_up_directory()
else:
self.play_uri(self.library[clicked - 1].uri, False)
self.play_uri(self.library[clicked - 1].uri,
False)
else:
self.play_uri(self.library[clicked].uri, False)
else:
@@ -65,16 +66,19 @@ class LibraryScreen():
self.go_up_directory()
else:
if self.library[
clicked - 1].type == mopidy.models.Ref.TRACK:
self.play_uri(self.library[clicked - 1].uri, True)
clicked - 1].type == mopidy.models.Ref.TRACK:
self.play_uri(
self.library[clicked - 1].uri, True)
else:
self.go_inside_directory(
self.library[clicked - 1].uri)
else:
if self.library[clicked].type == mopidy.models.Track:
if self.library[
clicked].type == mopidy.models.Track:
self.play_uri(self.library[clicked].uri, True)
else:
self.go_inside_directory(self.library[clicked].uri)
self.go_inside_directory(
self.library[clicked].uri)
def play_uri(self, uri, track):
self.manager.core.tracklist.clear()

32
mopidy_touchscreen/list_view.py
View File

@@ -1,6 +1,7 @@
import logging
from .screen_objects import ScreenObjectsManager, ScrollBar, TouchAndTextItem
from .screen_objects import ScreenObjectsManager, ScrollBar, \
TouchAndTextItem
from .input_manager import InputManager
logger = logging.getLogger(__name__)
@@ -21,20 +22,20 @@ class ListView():
self.set_list([])
self.selected = []
def get_dirty_area(self):
return self.screen_objects.get_dirty_area()
# Sets the list for the lisview. It should be an iterable of strings
def set_list(self, item_list):
self.screen_objects.clear()
self.screen_objects.clear()
self.list = item_list
self.list_size = len(item_list)
if self.max_rows < self.list_size:
self.scrollbar = True
scroll_bar = ScrollBar(
(self.pos[0] + self.size[0] - self.base_size, self.pos[1]),
(self.base_size, self.size[1]), self.list_size, self.max_rows)
self.screen_objects.set_touch_object("scrollbar", scroll_bar)
(self.pos[0] + self.size[0] - self.base_size,
self.pos[1]),
(self.base_size, self.size[1]), self.list_size,
self.max_rows)
self.screen_objects.set_touch_object("scrollbar",
scroll_bar)
else:
self.scrollbar = False
self.load_new_item_position(0)
@@ -55,13 +56,12 @@ class ListView():
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))
(width, -1))
self.screen_objects.set_touch_object(str(i), item)
i += 1
z += 1
def render(self, surface):
self.screen_objects.render(surface)
@@ -95,14 +95,16 @@ class ListView():
if self.current_item + self.max_rows > self.list_size:
self.current_item = self.list_size - self.max_rows
self.load_new_item_position(self.current_item)
self.screen_objects.get_touch_object("scrollbar").set_item(
self.screen_objects.get_touch_object(
"scrollbar").set_item(
self.current_item)
elif direction == -1:
self.current_item -= self.max_rows
if self.current_item < 0:
self.current_item = 0
self.load_new_item_position(self.current_item)
self.screen_objects.get_touch_object("scrollbar").set_item(
self.screen_objects.get_touch_object(
"scrollbar").set_item(
self.current_item)
self.set_selected(self.selected)
@@ -110,13 +112,15 @@ class ListView():
def set_selected(self, selected):
for number in self.selected:
try:
self.screen_objects.get_touch_object(str(number)).set_active(
self.screen_objects.get_touch_object(
str(number)).set_active(
False)
except KeyError:
pass
for number in selected:
try:
self.screen_objects.get_touch_object(str(number)).set_active(
self.screen_objects.get_touch_object(
str(number)).set_active(
True)
except KeyError:
pass

85
mopidy_touchscreen/main_screen.py
View File

@@ -6,13 +6,14 @@ import time
import urllib
import urllib2
from threading import Thread
import pygame
from .screen_objects import (Progressbar, ScreenObjectsManager, TextItem,
from .screen_objects import (Progressbar, ScreenObjectsManager,
TextItem,
TouchAndTextItem)
from .input_manager import InputManager
logger = logging.getLogger(__name__)
@@ -27,9 +28,7 @@ class MainScreen():
self.cache = cache
self.image = None
self.artists = None
self.dirty_area = []
self.track_duration = "00:00"
self.image_now_loaded = False
self.track_duration = "00:00"
self.touch_text_manager = ScreenObjectsManager()
current_track = self.core.playback.current_track.get()
if current_track is None:
@@ -42,18 +41,13 @@ class MainScreen():
self.touch_text_manager.get_touch_object(
"time_progress").set_value(
self.core.playback.time_position.get() / 1000)
self.touch_text_manager.get_touch_object("time_progress").set_text(
self.touch_text_manager.get_touch_object(
"time_progress").set_text(
time.strftime('%M:%S', time.gmtime(
self.core.playback.time_position.get() / 1000)) + "/" + self.track_duration)
if update_all:
if self.image is not None:
screen.blit(self.image, (self.base_size / 2, self.base_size + self.base_size / 2))
self.image_now_loaded = False
elif self.image_now_loaded:
self.dirty_area.append(pygame.Rect(self.base_size / 2, self.base_size + self.base_size / 2, self.image.get_rect().width,self.image.get_rect().height))
screen.blit(self.image, (self.base_size / 2, self.base_size + self.base_size / 2))
self.image_now_loaded = False
self.touch_text_manager.render(screen)
screen.blit(self.image, (
self.base_size / 2, self.base_size + self.base_size / 2))
self.touch_text_manager.render(screen)
return screen
def track_started(self, track):
@@ -61,7 +55,8 @@ class MainScreen():
x = self.base_size * 5
width = self.size[0] - self.base_size / 2 - x
self.track_duration = time.strftime('%M:%S', time.gmtime(track.length / 1000))
self.track_duration = time.strftime('%M:%S', time.gmtime(
track.length / 1000))
# Load all artists
self.artists = []
@@ -69,7 +64,8 @@ class MainScreen():
self.artists.append(artist)
# Track name
label = TextItem(self.fonts['base'], MainScreen.get_track_name(track),
label = TextItem(self.fonts['base'],
MainScreen.get_track_name(track),
(x, self.base_size * 2),
(width, self.size[1]))
self.touch_text_manager.set_object("track_name", label)
@@ -83,7 +79,8 @@ class MainScreen():
# Artist
label = TextItem(self.fonts['base'], self.get_artist_string(),
(x, self.base_size * 4), (width, self.size[1]))
(x, self.base_size * 4),
(width, self.size[1]))
self.touch_text_manager.set_object("artist_name", label)
# Previous track button
@@ -94,17 +91,24 @@ class MainScreen():
size_2 = self.fonts['icon'].size(u"\ue61d")[0]
button = TouchAndTextItem(self.fonts['icon'], u"\ue61d",
(self.size[0] - size_2, self.base_size * 6),
(self.size[0] - size_2,
self.base_size * 6),
None)
self.touch_text_manager.set_touch_object("next", button)
# Progress
progress = Progressbar(self.fonts['base'],time.strftime('%M:%S', time.gmtime(0)) + "/" + time.strftime('%M:%S',time.gmtime(0)),
progress = Progressbar(self.fonts['base'],
time.strftime('%M:%S', time.gmtime(
0)) + "/" + time.strftime('%M:%S',
time.gmtime(
0)),
(size_1, self.base_size * 6),
(
self.size[0] - size_1 - size_2, self.base_size),
self.size[0] - size_1 - size_2,
self.base_size),
track.length / 1000, False)
self.touch_text_manager.set_touch_object("time_progress", progress)
self.touch_text_manager.set_touch_object("time_progress",
progress)
self.track = track
if not self.is_image_in_cache():
@@ -113,10 +117,6 @@ class MainScreen():
else:
self.load_image()
def get_dirty_area(self):
dirty = self.touch_text_manager.get_dirty_area() + self.dirty_area
self.dirty_area = []
return dirty
def get_artist_string(self):
artists_string = ''
@@ -175,28 +175,36 @@ class MainScreen():
current = TextItem(self.fonts['base'],
MainScreen.get_track_name(self.track),
(self.base_size / 2, self.base_size * 2),
(self.base_size / 2,
self.base_size * 2),
(width, -1))
self.touch_text_manager.set_object("track_name", current)
current = TextItem(self.fonts['base'],
MainScreen.get_track_album_name(self.track),
(self.base_size / 2, self.base_size * 3),
MainScreen.get_track_album_name(
self.track),
(self.base_size / 2,
self.base_size * 3),
(width, -1))
self.touch_text_manager.set_object("album_name", current)
current = TextItem(self.fonts['base'], self.get_artist_string(),
(self.base_size / 2, self.base_size * 4),
current = TextItem(self.fonts['base'],
self.get_artist_string(),
(self.base_size / 2,
self.base_size * 4),
(width, -1))
self.touch_text_manager.set_object("artist_name", current)
def track_playback_ended(self, tl_track, time_position):
if self.image is not None:
self.dirty_area.append(pygame.Rect(self.base_size / 2, self.base_size + self.base_size / 2, self.image.get_rect().width,self.image.get_rect().height))
if self.image is not None:
self.dirty_area.append(pygame.Rect(self.base_size / 2,
self.base_size + self.base_size / 2,
self.image.get_rect().width,
self.image.get_rect().height))
self.image = None
self.track_duration = "00:00"
self.track_duration = "00:00"
# There is no cover so it will use all the screen size for the text
width = self.size[0] - self.base_size
@@ -223,7 +231,7 @@ class MainScreen():
self.get_cover_folder() +
self.get_image_file_name()).convert(),
(size, size))
self.image_now_loaded = True
self.image_now_loaded = True
def touch_event(self, event):
if event.type == InputManager.click:
@@ -233,9 +241,10 @@ class MainScreen():
for key in objects:
if key == "time_progress":
value = self.touch_text_manager.get_touch_object(
key).get_pos_value(event.current_pos) * 1000
key).get_pos_value(
event.current_pos) * 1000
self.core.playback.seek(value)
elif key == "previous":
self.core.playback.previous()
elif key == "next":

31
mopidy_touchscreen/menu_screen.py
View File

@@ -1,6 +1,5 @@
import os
import socket
import mopidy
from .screen_objects import ScreenObjectsManager, TouchAndTextItem
@@ -16,29 +15,38 @@ class MenuScreen():
self.screen_objects = ScreenObjectsManager()
# Exit mopidy button
button = TouchAndTextItem(self.manager.fonts['icon'], u"\ue611",
button = TouchAndTextItem(self.manager.fonts['icon'],
u"\ue611",
(0, self.base_size), None)
self.screen_objects.set_touch_object("exit_icon", button)
button = TouchAndTextItem(self.manager.fonts['base'], "Exit Mopidy",
(button.get_right_pos(), self.base_size),
button = TouchAndTextItem(self.manager.fonts['base'],
"Exit Mopidy",
(button.get_right_pos(),
self.base_size),
None)
self.screen_objects.set_touch_object("exit", button)
# Shutdown button
button = TouchAndTextItem(self.manager.fonts['icon'], u"\ue60b",
button = TouchAndTextItem(self.manager.fonts['icon'],
u"\ue60b",
(0, self.base_size * 2), None)
self.screen_objects.set_touch_object("shutdown_icon", button)
button = TouchAndTextItem(self.manager.fonts['base'], "Shutdown",
(button.get_right_pos(), self.base_size * 2),
button = TouchAndTextItem(self.manager.fonts['base'],
"Shutdown",
(button.get_right_pos(),
self.base_size * 2),
None)
self.screen_objects.set_touch_object("shutdown", button)
# Restart button
button = TouchAndTextItem(self.manager.fonts['icon'], u"\ue609",
button = TouchAndTextItem(self.manager.fonts['icon'],
u"\ue609",
(0, self.base_size * 3), None)
self.screen_objects.set_touch_object("restart_icon", button)
button = TouchAndTextItem(self.manager.fonts['base'], "Restart",
(button.get_right_pos(), self.base_size * 3),
button = TouchAndTextItem(self.manager.fonts['base'],
"Restart",
(button.get_right_pos(),
self.base_size * 3),
None)
self.screen_objects.set_touch_object("restart", button)
@@ -50,9 +58,6 @@ class MenuScreen():
def update(self, screen, update_all):
self.screen_objects.render(screen)
def get_dirty_area(self):
return self.screen_objects.get_dirty_area()
def touch_event(self, event):
if event.type == InputManager.click:
clicked = self.screen_objects.get_touch_objects_in_pos(

11
mopidy_touchscreen/playlist_screen.py
View File

@@ -8,16 +8,14 @@ class PlaylistScreen():
self.manager = manager
self.list_view = ListView((0, self.base_size), (
self.size[0], self.size[1] - 2 * self.base_size),
self.base_size, manager.fonts['base'])
self.base_size,
manager.fonts['base'])
self.playlists_strings = []
self.playlists = []
self.playlists_loaded()
def get_dirty_area(self):
return self.list_view.get_dirty_area()
def update(self, screen, update_all):
self.list_view.render(screen)
self.list_view.render(screen)
def playlists_loaded(self):
self.playlists_strings = []
@@ -31,5 +29,6 @@ class PlaylistScreen():
clicked = self.list_view.touch_event(touch_event)
if clicked is not None:
self.manager.core.tracklist.clear()
self.manager.core.tracklist.add(uri=self.playlists[clicked].uri)
self.manager.core.tracklist.add(
uri=self.playlists[clicked].uri)
self.manager.core.playback.play()

123
mopidy_touchscreen/screen_manager.py
View File

@@ -1,6 +1,5 @@
import logging
import traceback
import mopidy
import mopidy.core
import pygame
@@ -10,31 +9,35 @@ from .library_screen import LibraryScreen
from .main_screen import MainScreen
from .menu_screen import MenuScreen
from .playlist_screen import PlaylistScreen
from .screen_objects import Progressbar, ScreenObjectsManager, TouchAndTextItem
from .screen_objects import Progressbar, ScreenObjectsManager, \
TouchAndTextItem
from .input_manager import InputManager
from .tracklist import Tracklist
logger = logging.getLogger(__name__)
class ScreenManager():
def __init__(self, size, core, backend, cache):
def __init__(self, size, core, cache):
self.size = size
self.core = core
self.backend = backend
self.fonts = {}
self.current_screen = 0
self.base_size = self.size[1] / 8
font = resource_filename(Requirement.parse("mopidy-touchscreen"),
"mopidy_touchscreen/icomoon.ttf")
self.fonts['base'] = pygame.font.SysFont("verdana", self.base_size)
font = resource_filename(
Requirement.parse("mopidy-touchscreen"),
"mopidy_touchscreen/icomoon.ttf")
self.fonts['base'] = pygame.font.SysFont("verdana",
self.base_size)
self.fonts['icon'] = pygame.font.Font(font, self.base_size)
try:
self.screens = [MainScreen(size, self, cache, core, self.fonts),
Tracklist(size, self.base_size, self),
LibraryScreen(size, self.base_size, self),
PlaylistScreen(size, self.base_size, self),
MenuScreen(size, self.base_size, self)]
self.screens = [
MainScreen(size, self, cache, core, self.fonts),
Tracklist(size, self.base_size, self),
LibraryScreen(size, self.base_size, self),
PlaylistScreen(size, self.base_size, self),
MenuScreen(size, self.base_size, self)]
except:
traceback.print_exc()
self.track = None
@@ -42,8 +45,8 @@ class ScreenManager():
self.top_bar_objects = ScreenObjectsManager()
self.down_bar_objects = ScreenObjectsManager()
self.selected_zone = self.top_bar_objects
self.dirty_area = []
self.screen_changed = True
self.dirty_area = []
self.screen_changed = True
# Top bar
self.top_bar = pygame.Surface((self.size[0], self.base_size),
@@ -51,38 +54,45 @@ class ScreenManager():
self.top_bar.fill((0, 0, 0, 128))
# Play/pause
button = TouchAndTextItem(self.fonts['icon'], u"\ue615 ", (0, 0), None)
button = TouchAndTextItem(self.fonts['icon'], u"\ue615 ",
(0, 0), None)
self.top_bar_objects.set_touch_object("pause_play", button)
x = button.get_right_pos()
# Random
button = TouchAndTextItem(self.fonts['icon'], u"\ue629 ", (x, 0), None)
button = TouchAndTextItem(self.fonts['icon'], u"\ue629 ",
(x, 0), None)
self.top_bar_objects.set_touch_object("random", button)
x = button.get_right_pos()
# Repeat
button = TouchAndTextItem(self.fonts['icon'], u"\ue626", (x, 0), None)
button = TouchAndTextItem(self.fonts['icon'], u"\ue626",
(x, 0), None)
self.top_bar_objects.set_touch_object("repeat", button)
x = button.get_right_pos()
# Single
button = TouchAndTextItem(self.fonts['base'], " 1 ", (x, 0), None)
button = TouchAndTextItem(self.fonts['base'], " 1 ", (x, 0),
None)
self.top_bar_objects.set_touch_object("single", button)
x = button.get_right_pos()
# Internet
button = TouchAndTextItem(self.fonts['icon'], u"\ue602 ", (x, 0), None)
button = TouchAndTextItem(self.fonts['icon'], u"\ue602 ",
(x, 0), None)
self.top_bar_objects.set_touch_object("internet", button)
x = button.get_right_pos()
# Mute
button = TouchAndTextItem(self.fonts['icon'], u"\ue61f ", (x, 0), None)
button = TouchAndTextItem(self.fonts['icon'], u"\ue61f ",
(x, 0), None)
self.top_bar_objects.set_touch_object("mute", button)
x = button.get_right_pos()
# Volume
progress = Progressbar(self.fonts['base'], "100", (x, 0),
(self.size[0] - x, self.base_size), 100, True)
(self.size[0] - x, self.base_size),
100, True)
self.top_bar_objects.set_touch_object("volume", progress)
progress.set_value(self.core.playback.volume.get())
@@ -92,25 +102,29 @@ class ScreenManager():
# Main button
button = TouchAndTextItem(self.fonts['icon'], u" \ue600",
(0, self.base_size * 7), button_size)
(0, self.base_size * 7),
button_size)
self.down_bar_objects.set_touch_object("menu_0", button)
x = button.get_right_pos()
# Tracklist button
button = TouchAndTextItem(self.fonts['icon'], u" \ue60d",
(x, self.base_size * 7), button_size)
(x, self.base_size * 7),
button_size)
self.down_bar_objects.set_touch_object("menu_1", button)
x = button.get_right_pos()
# Library button
button = TouchAndTextItem(self.fonts['icon'], u" \ue604",
(x, self.base_size * 7), button_size)
(x, self.base_size * 7),
button_size)
self.down_bar_objects.set_touch_object("menu_2", button)
x = button.get_right_pos()
# Playlist button
button = TouchAndTextItem(self.fonts['icon'], u" \ue605",
(x, self.base_size * 7), button_size)
(x, self.base_size * 7),
button_size)
self.down_bar_objects.set_touch_object("menu_3", button)
x = button.get_right_pos()
@@ -121,7 +135,8 @@ class ScreenManager():
# Down bar
self.down_bar = pygame.Surface(
(self.size[0], self.size[1] - self.base_size * 7), pygame.SRCALPHA)
(self.size[0], self.size[1] - self.base_size * 7),
pygame.SRCALPHA)
self.down_bar.fill((0, 0, 0, 128))
self.options_changed()
@@ -135,13 +150,14 @@ class ScreenManager():
def update(self):
surface = pygame.Surface(self.size)
surface.fill([200,200,200])
self.screens[self.current_screen].update(surface, self.screen_changed)
surface.fill([200, 200, 200])
self.screens[self.current_screen].update(surface,
self.screen_changed)
surface.blit(self.top_bar, (0, 0))
surface.blit(self.down_bar, (0, self.base_size * 7))
self.top_bar_objects.render(surface)
self.down_bar_objects.render(surface)
self.screen_changed = False
self.screen_changed = False
return surface
def track_started(self, track):
@@ -150,12 +166,13 @@ class ScreenManager():
self.screens[1].track_started(track)
def get_dirty_area(self):
self.dirty_area = self.dirty_area + self.top_bar_objects.get_dirty_area()
self.dirty_area = self.dirty_area + self.top_bar_objects.get_dirty_area()
self.dirty_area = self.dirty_area + self.down_bar_objects.get_dirty_area()
self.dirty_area = self.dirty_area + self.screens[self.current_screen].get_dirty_area()
dirty_area = self.dirty_area
self.dirty_area = []
return dirty_area
self.dirty_area = self.dirty_area + self.screens[
self.current_screen].get_dirty_area()
dirty_area = self.dirty_area
self.dirty_area = []
return dirty_area
def track_playback_ended(self, tl_track, time_position):
self.screens[0].track_playback_ended(tl_track, time_position)
@@ -166,8 +183,9 @@ class ScreenManager():
if event.type == InputManager.click:
objects = self.top_bar_objects.get_touch_objects_in_pos(
event.current_pos)
objects.extend(self.down_bar_objects.get_touch_objects_in_pos(
event.current_pos))
objects.extend(
self.down_bar_objects.get_touch_objects_in_pos(
event.current_pos))
self.click_on_objects(objects, event)
elif event.type == InputManager.key and event.direction == InputManager.enter:
objects = [self.selected_zone.selected_key]
@@ -175,7 +193,8 @@ class ScreenManager():
elif event.type == InputManager.key:
if event.direction == InputManager.enter:
logger.error(self.selected_zone.selected_key)
self.click_on_objects([self.selected_zone.selected_key], event)
self.click_on_objects(
[self.selected_zone.selected_key], event)
else:
self.change_selection(event, None)
self.screens[self.current_screen].touch_event(event)
@@ -183,16 +202,20 @@ class ScreenManager():
def volume_changed(self, volume):
if not self.core.playback.mute.get():
if volume > 80:
self.top_bar_objects.get_touch_object("mute").set_text(
self.top_bar_objects.get_touch_object(
"mute").set_text(
u"\ue61f", False)
elif volume > 50:
self.top_bar_objects.get_touch_object("mute").set_text(
self.top_bar_objects.get_touch_object(
"mute").set_text(
u"\ue620", False)
elif volume > 20:
self.top_bar_objects.get_touch_object("mute").set_text(
self.top_bar_objects.get_touch_object(
"mute").set_text(
u"\ue621", False)
else:
self.top_bar_objects.get_touch_object("mute").set_text(
self.top_bar_objects.get_touch_object(
"mute").set_text(
u"\ue622", False)
self.top_bar_objects.get_touch_object("volume").set_value(
volume)
@@ -227,13 +250,12 @@ class ScreenManager():
elif key[:-1] == "menu_":
self.change_screen(int(key[-1:]))
def change_volume(self,event):
def change_volume(self, event):
manager = self.top_bar_objects
volume = manager.get_touch_object("volume")
pos = event.current_pos
value = volume.get_pos_value(pos)
self.backend.tell(
{'action': 'volume', 'value': value})
self.core.playback.volume = value
self.volume_changed(value)
def playback_state_changed(self, old_state, new_state):
@@ -265,13 +287,14 @@ class ScreenManager():
self.core.tracklist.single.get())
def change_screen(self, new_screen):
self.screen_changed = True
self.screen_changed = True
self.down_bar_objects.get_touch_object(
"menu_" + str(self.current_screen)).set_active(False)
self.current_screen = new_screen
self.down_bar_objects.get_touch_object(
"menu_" + str(new_screen)).set_active(True)
self.dirty_area.append(pygame.Rect(0,0,self.size[0],self.size[1]))
self.dirty_area.append(
pygame.Rect(0, 0, self.size[0], self.size[1]))
def playlists_loaded(self):
self.screens[3].playlists_loaded()
@@ -287,13 +310,17 @@ class ScreenManager():
def change_selection(self, event, pos):
if self.selected_zone == self.top_bar_objects:
if not self.top_bar_objects.change_selected(event.direction, pos) and event.direction == InputManager.down:
if not self.top_bar_objects.change_selected(
event.direction,
pos) and event.direction == InputManager.down:
pos = self.top_bar_objects.selected.pos
self.selected_zone = self.down_bar_objects
self.top_bar_objects.set_selected(None)
self.change_selection(event, pos)
elif self.selected_zone == self.down_bar_objects:
if not self.down_bar_objects.change_selected(event.direction, pos) and event.direction == InputManager.up:
if not self.down_bar_objects.change_selected(
event.direction,
pos) and event.direction == InputManager.up:
pos = self.down_bar_objects.selected.pos
self.selected_zone = self.top_bar_objects
self.down_bar_objects.set_selected(None)

150
mopidy_touchscreen/screen_objects.py
View File

@@ -1,6 +1,5 @@
import logging
import math
import pygame
from .input_manager import InputManager
@@ -15,23 +14,13 @@ class ScreenObjectsManager():
self.text_objects = {}
self.selected = None
self.selected_key = None
self.dirty_area = []
def clear(self):
for key in self.touch_objects:
self.dirty_area.append(self.touch_objects[key].rect_in_pos)
for key in self.text_objects:
self.dirty_area.append(self.text_objects[key].rect_in_pos)
self.touch_objects = {}
self.touch_objects = {}
self.text_objects = {}
def set_object(self, key, add_object):
try:
self.dirty_area.append(self.text_objects[key].rect_in_pos)
except KeyError:
pass
self.text_objects[key] = add_object
self.dirty_area.append(add_object.rect_in_pos)
def get_object(self, key):
return self.text_objects[key]
@@ -45,19 +34,12 @@ class ScreenObjectsManager():
def render(self, surface):
for key in self.text_objects:
if self.text_objects[key].update():
self.dirty_area.append(self.text_objects[key].rect_in_pos)
self.text_objects[key].update()
self.text_objects[key].render(surface)
for key in self.touch_objects:
if self.touch_objects[key].update():
self.dirty_area.append(self.touch_objects[key].rect_in_pos)
self.touch_objects[key].update()
self.touch_objects[key].render(surface)
def get_dirty_area(self):
dirty_area = self.dirty_area
self.dirty_area = []
return dirty_area
def get_touch_objects_in_pos(self, pos):
touched_objects = []
for key in self.touch_objects:
@@ -89,16 +71,20 @@ class ScreenObjectsManager():
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)
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)
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)
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)
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
@@ -175,7 +161,8 @@ class ScreenObjectsManager():
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:
elif objects[key].pos[1] >= pos[1] and \
objects[key].pos[1] < best_pos:
best_pos = objects[key].pos[1]
best_key = key
else:
@@ -183,7 +170,8 @@ class ScreenObjectsManager():
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:
elif objects[key].pos[1] <= pos[1] and \
objects[key].pos[1] > best_pos:
best_pos = objects[key].pos[1]
best_key = key
else:
@@ -192,7 +180,8 @@ class ScreenObjectsManager():
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:
elif objects[key].pos[0] >= pos[0] and \
objects[key].pos[0] < best_pos:
best_pos = objects[key].pos[0]
best_key = key
else:
@@ -200,35 +189,28 @@ class ScreenObjectsManager():
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:
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):
self.pos = pos
self.size = size
self.dirty = True
self.rect = pygame.Rect(0, 0, self.size[0], self.size[1])
self.rect_in_pos = pygame.Rect(self.pos[0], self.pos[1], self.size[0],
self.rect_in_pos = pygame.Rect(self.pos[0], self.pos[1],
self.size[0],
self.size[1])
def get_right_pos(self):
return self.pos[0] + self.size[0]
# Returns if must be redraw
def update(self):
if self.dirty:
self.dirty = False
return True
else:
return False
pass
class TextItem(BaseItem):
@@ -246,12 +228,14 @@ class TextItem(BaseItem):
else:
BaseItem.__init__(self, pos, self.font.size(text))
if size is not None:
if self.pos[0] + self.box.get_rect().width > pos[0] + size[0]:
if self.pos[0] + self.box.get_rect().width > pos[0] + \
size[0]:
self.fit_horizontal = False
self.step = 0
else:
self.fit_horizontal = True
if self.pos[1] + self.box.get_rect().height > pos[1] + size[1]:
if self.pos[1] + self.box.get_rect().height > pos[1] + \
size[1]:
self.fit_vertical = False
else:
self.fit_vertical = True
@@ -262,30 +246,30 @@ class TextItem(BaseItem):
def update(self):
if not self.fit_horizontal:
if self.step > self.box.get_rect().width:
self.step = -self.size[0]
self.step = -self.size[0]
else:
self.step = self.step + 1
return True
else:
return BaseItem.update(self)
self.step = self.step + 1
return True
else:
return BaseItem.update(self)
def render(self, surface):
if self.fit_horizontal:
surface.blit(self.box, self.pos, area=self.rect)
else:
surface.blit(self.box, self.pos, area=pygame.Rect(self.step, 0, self.size[0], self.size[1]))
surface.blit(self.box, self.pos,
area=pygame.Rect(self.step, 0, self.size[0],
self.size[1]))
def set_text(self, text, change_size):
if text != self.text:
self.dirty = True
if text != self.text:
if change_size:
TextItem.__init__(self, self.font, text, self.pos, None)
TextItem.__init__(self, self.font, text, self.pos,
None)
else:
TextItem.__init__(self, self.font, text, self.pos, self.size)
return True
else:
return False
TextItem.__init__(self, self.font, text, self.pos,
self.size)
class TouchObject(BaseItem):
@@ -298,11 +282,9 @@ class TouchObject(BaseItem):
return self.rect_in_pos.collidepoint(pos)
def set_active(self, active):
self.dirty = True
self.active = active
def set_selected(self, selected):
self.dirty = True
self.selected = selected
@@ -312,21 +294,25 @@ class TouchAndTextItem(TouchObject, TextItem):
TouchObject.__init__(self, pos, self.size)
self.active_color = (0, 150, 255)
self.selected_color = (150, 0, 255)
self.active_box = self.font.render(text, True, self.active_color)
self.selected_box = self.font.render(text, True, self.selected_color)
self.active_box = self.font.render(text, True,
self.active_color)
self.selected_box = self.font.render(text, True,
self.selected_color)
def update(self):
return TextItem.update(self)
TextItem.update(self)
def set_text(self, text, change_size):
self.dirty = True
TextItem.set_text(self, text, change_size)
self.active_box = self.font.render(text, True, self.active_color)
self.selected_box = self.font.render(text, True, self.selected_color)
self.active_box = self.font.render(text, True,
self.active_color)
self.selected_box = self.font.render(text, True,
self.selected_color)
def render(self, surface):
if not self.fit_horizontal:
self.rect = pygame.Rect(self.step, 0, self.size[0], self.size[1])
self.rect = pygame.Rect(self.step, 0, self.size[0],
self.size[1])
if self.selected:
surface.blit(self.selected_box, self.pos, area=self.rect)
elif self.active:
@@ -347,14 +333,16 @@ class Progressbar(TouchObject):
self.value_text = value_text
if value_text:
self.text = TextItem(font, str(max_value), pos, None)
self.text.pos = (self.pos[0] + self.size[0] / 2 - self.text.size[0] /
2, self.text.pos[1])
self.text.pos = (
self.pos[0] + self.size[0] / 2 - self.text.size[0] /
2, self.text.pos[1])
self.text.set_text(str(self.value), True)
else:
self.text = TextItem(font, text, pos, None)
self.text.pos = (self.pos[0] + self.size[0] / 2 - self.text.size[0] /
2, self.text.pos[1])
self.text.pos = (
self.pos[0] + self.size[0] / 2 - self.text.size[0] /
2, self.text.pos[1])
def render(self, surface):
surface.blit(self.surface, self.pos)
@@ -362,12 +350,12 @@ class Progressbar(TouchObject):
def set_value(self, value):
if value != self.value:
self.dirty = True
self.value = value
if self.value_text:
self.set_text(str(self.value))
self.text.pos = (self.pos[0] + self.size[0] / 2 - self.text.size[0] /
2, self.text.pos[1])
self.text.pos = (
self.pos[0] + self.size[0] / 2 - self.text.size[0] /
2, self.text.pos[1])
self.surface.fill(self.back_color)
pos_pixel = value * self.size[0] / self.max
rect = pygame.Rect(0, 0, pos_pixel, self.size[1])
@@ -378,12 +366,13 @@ class Progressbar(TouchObject):
return x * self.max / self.size[0]
def set_text(self, text):
self.dirty = self.text.set_text(text, True)
self.text.set_text(text, True)
class ScrollBar(TouchObject):
def __init__(self, pos, size, max_value, items_on_screen):
BaseItem.__init__(self, pos, (pos[0] + size[0], pos[1] + size[1]))
BaseItem.__init__(self, pos,
(pos[0] + size[0], pos[1] + size[1]))
self.pos = pos
self.size = size
self.max = max_value
@@ -403,7 +392,8 @@ class ScrollBar(TouchObject):
def render(self, surface):
surface.blit(self.back_bar, self.pos)
surface.blit(self.bar, (self.pos[0], self.pos[1] + self.bar_pos))
surface.blit(self.bar,
(self.pos[0], self.pos[1] + self.bar_pos))
def touch(self, pos):
if pos[1] < self.pos[1] + self.bar_pos:
@@ -414,7 +404,7 @@ class ScrollBar(TouchObject):
return 0
def set_item(self, current_item):
self.dirty = True
self.current_item = current_item
self.bar_pos = float(self.current_item) / float(self.max) * float(
self.bar_pos = float(self.current_item) / float(
self.max) * float(
self.size[1])

25
mopidy_touchscreen/touch_screen.py
View File

@@ -9,32 +9,35 @@ from mopidy import core
from .screen_manager import ScreenManager
logger = logging.getLogger(__name__)
class TouchScreen(pykka.ThreadingActor, core.CoreListener):
def __init__(self, config, core):
super(TouchScreen, self).__init__()
self.backend = \
pykka.ActorRegistry.get_by_class_name("TouchScreenBackend")[0]
self.core = core
self.running = False
self.screen_size = (config['touchscreen']['screen_width'],
config['touchscreen']['screen_height'])
self.cache_dir = config['touchscreen']['cache_dir']
self.fullscreen = config['touchscreen']['fullscreen']
os.environ["SDL_FBDEV"] = config['touchscreen']['sdl_fbdev']
os.environ["SDL_MOUSEDRV"] = config['touchscreen']['sdl_mousdrv']
os.environ["SDL_MOUSEDEV"] = config['touchscreen']['sdl_mousedev']
os.environ["SDL_FBDEV"] = config['touchscreen']['sdl_fbdev']
os.environ["SDL_MOUSEDRV"] = config['touchscreen'][
'sdl_mousdrv']
os.environ["SDL_MOUSEDEV"] = config['touchscreen'][
'sdl_mousedev']
pygame.init()
self.cursor = config['touchscreen']['cursor']
self.screen_manager = ScreenManager(self.screen_size, self.core,
self.backend, self.cache_dir)
self.screen_manager = ScreenManager(self.screen_size,
self.core,
self.cache_dir)
# Raspberry pi GPIO
self.gpio = config['touchscreen']['gpio']
if self.gpio:
from .gpio_inpput_manager import GPIOManager
pins = {}
pins['left'] = config['touchscreen']['gpio_left']
pins['right'] = config['touchscreen']['gpio_right']
@@ -54,7 +57,7 @@ class TouchScreen(pykka.ThreadingActor, core.CoreListener):
while self.running:
clock.tick(15)
screen.blit(self.screen_manager.update(), (0, 0))
pygame.display.update(self.screen_manager.get_dirty_area())
pygame.display.flip()
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
@@ -86,7 +89,8 @@ class TouchScreen(pykka.ThreadingActor, core.CoreListener):
self.screen_manager.volume_changed(volume)
def playback_state_changed(self, old_state, new_state):
self.screen_manager.playback_state_changed(old_state, new_state)
self.screen_manager.playback_state_changed(old_state,
new_state)
def tracklist_changed(self):
try:
@@ -95,7 +99,8 @@ class TouchScreen(pykka.ThreadingActor, core.CoreListener):
traceback.print_exc()
def track_playback_ended(self, tl_track, time_position):
self.screen_manager.track_playback_ended(tl_track, time_position)
self.screen_manager.track_playback_ended(tl_track,
time_position)
def options_changed(self):
try:

21
mopidy_touchscreen/touch_screen_backend.py
View File

@@ -1,21 +0,0 @@
import logging
import pykka
from mopidy import backend
logger = logging.getLogger(__name__)
class TouchScreenBackend(pykka.ThreadingActor, backend.Backend):
def __init__(self, config, audio):
super(TouchScreenBackend, self).__init__()
self.audio = audio
def on_receive(self, message):
action = message['action']
if action == 'volume':
self.audio.set_volume(message['value'])
elif action == "mute":
self.audio.set_mute(message['value'])
elif action == "random":
self.audio.set_random(message['value'])

8
mopidy_touchscreen/tracklist.py
View File

@@ -9,16 +9,14 @@ class Tracklist():
self.manager = manager
self.list_view = ListView((0, self.base_size), (
self.size[0], self.size[1] - 2 * self.base_size),
self.base_size, manager.fonts['base'])
self.base_size,
manager.fonts['base'])
self.tracks = []
self.tracks_strings = []
self.update_list()
def get_dirty_area(self):
return self.list_view.get_dirty_area()
def update(self, screen, update_all):
self.list_view.render(screen)
self.list_view.render(screen)
def tracklist_changed(self):
self.update_list()