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

Recover files

Browse Source
This commit is contained in:
Ander
2015-04-09 01:21:50 +02:00
parent c2b3a16cd3
commit 660258f044
26 changed files with 687 additions and 595 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@@ -3,8 +3,9 @@
*.swp *.swp
*~ *~
.coverage .coverage
.idea/
.tox/ .tox/
MANIFEST MANIFEST
build/ build/
dist/ dist/
.idea/ xunit-*.xml

69
README.rst
View File

@@ -1,6 +1,6 @@
**************************** ******************
Mopidy-Touchscreen Mopidy-Touchscreen
**************************** ******************
.. image:: https://img.shields.io/pypi/v/Mopidy-Touchscreen.svg?style=flat .. image:: https://img.shields.io/pypi/v/Mopidy-Touchscreen.svg?style=flat
:target: https://pypi.python.org/pypi/Mopidy-Touchscreen/ :target: https://pypi.python.org/pypi/Mopidy-Touchscreen/
@@ -10,25 +10,28 @@ Mopidy-Touchscreen
:target: https://pypi.python.org/pypi/Mopidy-Touchscreen/ :target: https://pypi.python.org/pypi/Mopidy-Touchscreen/
:alt: Number of PyPI downloads :alt: Number of PyPI downloads
.. image:: https://img.shields.io/travis/9and3r/mopidy-touchscreen/master.png?style=flat .. image:: https://img.shields.io/travis/9and3r/mopidy-touchscreen/develop.svg?style=flat
:target: https://travis-ci.org/9and3r/mopidy-touchscreen :target: https://travis-ci.org/9and3r/mopidy-touchscreen
:alt: Travis CI build status :alt: Travis CI build status
.. image:: https://img.shields.io/coveralls/9and3r/mopidy-touchscreen/master.svg?style=flat .. image:: https://img.shields.io/coveralls/9and3r/mopidy-touchscreen/develop.svg?style=flat
:target: https://coveralls.io/r/9and3r/mopidy-touchscreen?branch=master :target: https://coveralls.io/r/9and3r/mopidy-touchscreen?branch=develop
:alt: Test coverage :alt: Test coverage
Extension for displaying track info and controlling Mopidy from a touch screen using `PyGame <http://www.pygame.org/>`_/SDL. Extension for displaying track info and controlling Mopidy from a touch screen
using `PyGame <http://www.pygame.org/>`_/SDL.
Cover images are downloaded from `last.fm <http://www.last.fm/api>`_ Cover images are downloaded from `last.fm <http://www.last.fm/api>`_
Dependencies Dependencies
============ ============
- ``Mopidy`` >= 0.18 - ``Mopidy`` >= 1.0
- ``Pykka`` >= 1.1 - ``Pykka`` >= 1.1
- ``pygame`` - ``pygame``
Installation Installation
============ ============
@@ -56,12 +59,23 @@ Mopidy-Touchscreen to your Mopidy configuration file::
The following configuration values are available: The following configuration values are available:
- ``touchscreen/enabled``: If the Touchscreen extension should be enabled or not. - ``touchscreen/enabled``: If the Touchscreen extension should be enabled or
- ``touchscreen/screen_width``: The width of the resolution you want to use in pixels. not.
- ``touchscreen/screen_height``: The width of the resolution you want to use in pixels.
- ``touchscreen/cursor``: If the mouse cursor should be shown. (If you use a touchscreen it should be false) - ``touchscreen/screen_width``: The width of the resolution you want to use in
- ``touchscreen/fullscreen``: If you want to be shown as a window or in fullscreen. pixels.
- ``touchscreen/screen_width``: The folder to be used as cache. Defaults to ``$XDG_CACHE_DIR/mopidy/touchscreen``, which usually means
- ``touchscreen/screen_height``: The width of the resolution you want to use in
pixels.
- ``touchscreen/cursor``: If the mouse cursor should be shown. (If you use a
touchscreen it should be false)
- ``touchscreen/fullscreen``: If you want to be shown as a window or in
fullscreen.
- ``touchscreen/screen_width``: The folder to be used as cache. Defaults to
``$XDG_CACHE_DIR/mopidy/touchscreen``, which usually means
``~/.cache/mopidy/touchscreen`` ``~/.cache/mopidy/touchscreen``
@@ -92,7 +106,7 @@ To find your values find an example of using pygame with your LCD Shield and it
os.environ["SDL_MOUSEDRV"] = "TSLIB" os.environ["SDL_MOUSEDRV"] = "TSLIB"
os.environ["SDL_MOUSEDEV"] = "event0" os.environ["SDL_MOUSEDEV"] = "event0"
Run mopidy with root privileges Run Mopidy with root privileges
``````````````````````````````` ```````````````````````````````
You can use ``sudo mopidy``. You can use ``sudo mopidy``.
@@ -108,6 +122,7 @@ Help
You can use `mopidy discuss <https://discuss.mopidy.com/>`_ You can use `mopidy discuss <https://discuss.mopidy.com/>`_
or send an email to `9and3r@gmail.com <mailto:9and3r@gmail.com>`_ or send an email to `9and3r@gmail.com <mailto:9and3r@gmail.com>`_
Features Features
======== ========
@@ -132,16 +147,19 @@ Planned
* Use keyboard or GPIO buttons instead of touchscreen * Use keyboard or GPIO buttons instead of touchscreen
Screenshots Screenshots
=========== ===========
.. image:: http://i60.tinypic.com/qqsait.jpg .. image:: http://i60.tinypic.com/qqsait.jpg
Video Video
===== =====
`Example video running the extension <https://www.youtube.com/watch?v=KuYoIb8Q2LI>`_ `Example video running the extension <https://www.youtube.com/watch?v=KuYoIb8Q2LI>`_
Project resources Project resources
================= =================
@@ -153,25 +171,26 @@ Project resources
Changelog Changelog
========= =========
v0.3.2 v0.4.0 (UNRELEASED)
---------------------------------------- -------------------
- Require Mopidy v1.0
- Update to work with changed core playback API in Mopidy 1.0
v0.3.2 (2015-01-09)
-------------------
- Bug Fixes - Bug Fixes
- UI changes - UI changes
- Smoth text scrolling - Smoth text scrolling
- Search albums, artist or songs (Not fully implemented. Basic functionality) - Search albums, artist or songs (Not fully implemented. Basic functionality)
v0.2.1 v0.2.1 (2014-08-02)
---------------------------------------- -------------------
- Font will be included on installation - Font will be included on installation
v0.2.0 v0.2.0 (2014-08-02)
---------------------------------------- -------------------
- First working version - First working version
v0.1.0 (UNRELEASED)
----------------------------------------
- Initial release.

62
docs/index.rst
View File

@@ -40,8 +40,8 @@ Or, if available, install the Debian/Ubuntu package from `apt.mopidy.com
<http://apt.mopidy.com/>`_. <http://apt.mopidy.com/>`_.
Configuration Basic Configuration
============= ===================
Before starting Mopidy, you must add configuration for Before starting Mopidy, you must add configuration for
Mopidy-Touchscreen to your Mopidy configuration file:: Mopidy-Touchscreen to your Mopidy configuration file::
@@ -62,10 +62,54 @@ The following configuration values are available:
- ``touchscreen/cursor``: If the mouse cursor should be shown. (If you use a touchscreen it should be false) - ``touchscreen/cursor``: If the mouse cursor should be shown. (If you use a touchscreen it should be false)
- ``touchscreen/fullscreen``: If you want to be shown as a window or in fullscreen. - ``touchscreen/fullscreen``: If you want to be shown as a window or in fullscreen.
- ``touchscreen/screen_width``: The folder to be used as cache. Defaults to ``$XDG_CACHE_DIR/mopidy/touchscreen``, which usually means - ``touchscreen/screen_width``: The folder to be used as cache. Defaults to ``$XDG_CACHE_DIR/mopidy/touchscreen``, which usually means
``~/.cache/mopidy/spotify`` ``~/.cache/mopidy/touchscreen``
How to Setup
============
Use the basic configuration to setup as most standard screens works fine without further configuration.
Raspberry Pi and LCD Shields
----------------------------
If you are using a LCD Shield in Raspberry Pi you need to config your LCD and run mopidy with root privileges:
Configure your LCD Shield
`````````````````````````
Add to the config the next variables::
[touchscreen]
sdl_fbdev = /dev/fb1
sdl_mousdrv = TSLIB
sdl_mousedev = event0
This is just an example. It may work but each LCD Shield seems to have its own configuration.
To find your values find an example of using pygame with your LCD Shield and it should be something like this in the code::
os.environ["SDL_FBDEV"] = "/dev/fb1"
os.environ["SDL_MOUSEDRV"] = "TSLIB"
os.environ["SDL_MOUSEDEV"] = "event0"
Run mopidy with root privileges
```````````````````````````````
You can use ``sudo mopidy``.
In case you are using musicbox edit ``/etc/init.d/mopidy`` file. Change ``DAEMON_USER=mopidy`` to ``DAEMON_USER=root``
Do not forget that this is a workaround and that mopidy will run with root privileges.
Help
====
You can use `mopidy discuss <https://discuss.mopidy.com/>`_
or send an email to `9and3r@gmail.com <mailto:9and3r@gmail.com>`_
Features Features
============= ========
Working Working
------- -------
@@ -109,10 +153,18 @@ Project resources
Changelog Changelog
========= =========
v0.3.2
----------------------------------------
- Bug Fixes
- UI changes
- Smoth text scrolling
- Search albums, artist or songs (Not fully implemented. Basic functionality)
v0.2.1 v0.2.1
---------------------------------------- ----------------------------------------
-Font will be included on instalation - Font will be included on installation
v0.2.0 v0.2.0
---------------------------------------- ----------------------------------------

7
mopidy_touchscreen/__init__.py
View File

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

61
mopidy_touchscreen/dynamic_background.py
View File

@@ -1,61 +0,0 @@
import random
change_speed = 2
import pygame
class DynamicBackground():
def __init__(self, size):
self.size = size
self.current = get_valid_color()
self.target = get_valid_color()
self.surface = None
def draw_background(self, surface):
same = True
for x in range(0, 3):
if abs(self.current[x]-self.target[x]) < change_speed:
self.current[x] = self.target[x]
else:
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.current != self.target:
same = False
#if same:
# self.target = get_valid_color()
surface.fill(self.current)
if self.surface is not None:
surface.blit(self.surface,(0,0))
def set_target_color(self, color, surface):
self.target = [color[0], color[1], color[2]]
#irudi = pygame.Surface(surface.get_size())
#pygame.transform.laplacian(surface, irudi)
irudi = surface
target = pygame.Surface(self.size)
pygame.transform.smoothscale(irudi, self.size, target)
target.set_alpha(80)
self.surface = target
# 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

4
mopidy_touchscreen/graphic_utils/__init__.py Normal file
View File

@@ -0,0 +1,4 @@
# flake8: noqa
from dynamic_background import DynamicBackground
from list_view import ListView
from screen_objects import *

106
mopidy_touchscreen/graphic_utils/dynamic_background.py Normal file
View File

@@ -0,0 +1,106 @@
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

83
mopidy_touchscreen/list_view.py → mopidy_touchscreen/graphic_utils/list_view.py
View File

@@ -1,8 +1,9 @@
import logging import logging
from .screen_objects import ScreenObjectsManager, ScrollBar, \ from screen_objects import ScreenObjectsManager, ScrollBar, \
TouchAndTextItem TouchAndTextItem
from .input_manager import InputManager
from ..input import InputManager
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@@ -19,10 +20,12 @@ class ListView():
self.list_size = 0 self.list_size = 0
self.list = [] self.list = []
self.scrollbar = False self.scrollbar = False
self.selected = None
self.active = []
self.set_list([]) self.set_list([])
self.selected = []
# Sets the list for the lisview. It should be an iterable of strings # Sets the list for the lisview.
# It should be an iterable of strings
def set_list(self, item_list): def set_list(self, item_list):
self.screen_objects.clear() self.screen_objects.clear()
self.list = item_list self.list = item_list
@@ -38,6 +41,10 @@ class ListView():
scroll_bar) scroll_bar)
else: else:
self.scrollbar = False self.scrollbar = False
if self.list_size > 0:
self.selected = 0
else:
self.selected = None
self.load_new_item_position(0) self.load_new_item_position(0)
# Will load items currently displaying in item_pos # Will load items currently displaying in item_pos
@@ -55,12 +62,12 @@ class ListView():
width = self.size[0] width = self.size[0]
while i < self.list_size and z < self.max_rows: while i < self.list_size and z < self.max_rows:
item = TouchAndTextItem(self.font, self.list[i], ( 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) self.screen_objects.set_touch_object(str(i), item)
i += 1 i += 1
z += 1 z += 1
self.reload_selected()
def render(self, surface): def render(self, surface):
self.screen_objects.render(surface) self.screen_objects.render(surface)
@@ -73,12 +80,22 @@ class ListView():
if objects is not None: if objects is not None:
for key in objects: for key in objects:
if key == "scrollbar": if key == "scrollbar":
direction = self.screen_objects.get_touch_object( direction = \
key).touch(touch_event.current_pos) self.screen_objects.get_touch_object(
key).touch(touch_event.current_pos)
if direction != 0: if direction != 0:
self.move_to(direction) self.move_to(direction)
else: else:
return int(key) return int(key)
elif (touch_event.type == InputManager.key and
self.selected is not None):
if touch_event.direction == InputManager.enter:
if self.selected is not None:
return self.selected
elif touch_event.direction == InputManager.up:
self.set_selected(self.selected-1)
elif touch_event.direction == InputManager.down:
self.set_selected(self.selected+1)
elif touch_event.type == InputManager.swipe: elif touch_event.type == InputManager.swipe:
if touch_event.direction == InputManager.up: if touch_event.direction == InputManager.up:
self.move_to(-1) self.move_to(-1)
@@ -106,22 +123,58 @@ class ListView():
self.screen_objects.get_touch_object( self.screen_objects.get_touch_object(
"scrollbar").set_item( "scrollbar").set_item(
self.current_item) self.current_item)
self.set_selected(self.selected) self.set_active(self.active)
# Set selected items # Set active items
def set_selected(self, selected): def set_active(self, active):
for number in self.selected: for number in self.active:
try: try:
self.screen_objects.get_touch_object( self.screen_objects.get_touch_object(
str(number)).set_active( str(number)).set_active(
False) False)
except KeyError: except KeyError:
pass pass
for number in selected: for number in active:
try: try:
self.screen_objects.get_touch_object( self.screen_objects.get_touch_object(
str(number)).set_active( str(number)).set_active(
True) True)
except KeyError: except KeyError:
pass pass
self.selected = selected self.active = active
def set_selected(self, selected):
if selected > -1 and selected < len(self.list):
if self.selected is not None:
try:
self.screen_objects.get_touch_object(
str(self.selected)).set_selected(
False)
except KeyError:
pass
if selected is not None:
try:
self.screen_objects.get_touch_object(
str(selected)).set_selected(
True)
except KeyError:
pass
self.selected = selected
self.set_selected_on_screen()
def set_selected_on_screen(self):
if self.current_item + self.max_rows <= self.selected:
self.move_to(1)
self.set_selected_on_screen()
elif self.current_item > self.selected:
self.move_to(-1)
self.set_selected_on_screen()
def reload_selected(self):
if self.selected is not None:
try:
self.screen_objects.get_touch_object(
str(self.selected)).set_selected(
True)
except KeyError:
pass

248
mopidy_touchscreen/screen_objects.py → mopidy_touchscreen/graphic_utils/screen_objects.py
View File

@@ -1,8 +1,7 @@
import logging import logging
import math import math
import pygame
from .input_manager import InputManager import pygame
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@@ -31,7 +30,6 @@ class ScreenObjectsManager():
def get_touch_object(self, key): def get_touch_object(self, key):
return self.touch_objects[key] return self.touch_objects[key]
def render(self, surface): def render(self, surface):
for key in self.text_objects: for key in self.text_objects:
self.text_objects[key].update() self.text_objects[key].update()
@@ -67,134 +65,6 @@ class ScreenObjectsManager():
self.selected = None self.selected = None
self.selected_key = None self.selected_key = None
def change_selected(self, direction, pos):
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(): class BaseItem():
def __init__(self, pos, size): def __init__(self, pos, size):
@@ -208,20 +78,20 @@ class BaseItem():
def get_right_pos(self): def get_right_pos(self):
return self.pos[0] + self.size[0] return self.pos[0] + self.size[0]
def update(self): def update(self):
pass pass
class TextItem(BaseItem): class TextItem(BaseItem):
scroll_speed = 2 scroll_speed = 5
def __init__(self, font, text, pos, size, center=False): def __init__(self, font, text, pos, size, center=False):
self.font = font self.font = font
self.text = text self.text = text
self.color = (255, 255, 255) self.color = (255, 255, 255)
self.box = self.font.render(text, True, self.color) self.box = self.font.render(text, True, self.color)
self.box = self.box.convert_alpha()
if size is not None: if size is not None:
if size[1] == -1: if size[1] == -1:
height = self.font.size(text)[1] height = self.font.size(text)[1]
@@ -235,6 +105,8 @@ class TextItem(BaseItem):
size[0]: size[0]:
self.fit_horizontal = False self.fit_horizontal = False
self.step = 0 self.step = 0
self.step_2 = None
self.scroll_white_gap = self.font.get_height() * 4
else: else:
self.fit_horizontal = True self.fit_horizontal = True
if self.pos[1] + self.box.get_rect().height > pos[1] + \ if self.pos[1] + self.box.get_rect().height > pos[1] + \
@@ -249,26 +121,43 @@ class TextItem(BaseItem):
self.center = center self.center = center
if self.center: if self.center:
if self.fit_horizontal: if self.fit_horizontal:
self.margin = (self.size[0]-self.box.get_rect().width)/2 self.margin = (self.size[0] -
self.box.get_rect().width)/2
def update(self): def update(self):
if not self.fit_horizontal: if not self.fit_horizontal:
if self.step > self.box.get_rect().width: self.step += TextItem.scroll_speed
self.step = -self.size[0] 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 + self.scroll_white_gap
else: else:
self.step = self.step + TextItem.scroll_speed self.step_2 -= TextItem.scroll_speed
if self.step_2 < 0:
self.step = 0 - self.step_2
self.step_2 = None
return True return True
else: else:
return BaseItem.update(self) return BaseItem.update(self)
def render(self, surface): def render(self, surface):
if self.fit_horizontal: 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: else:
surface.blit(self.box, self.pos, surface.blit(self.box, self.pos,
area=pygame.Rect(self.step, 0, self.size[0], area=pygame.Rect(self.step, 0, self.size[0],
self.size[1])) self.size[1]))
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,
self.size[1]))
def set_text(self, text, change_size): def set_text(self, text, change_size):
if text != self.text: if text != self.text:
@@ -285,6 +174,15 @@ class TouchObject(BaseItem):
BaseItem.__init__(self, pos, size) BaseItem.__init__(self, pos, size)
self.active = False self.active = False
self.selected = 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 = \
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)
def is_pos_inside(self, pos): def is_pos_inside(self, pos):
return self.rect_in_pos.collidepoint(pos) return self.rect_in_pos.collidepoint(pos)
@@ -295,38 +193,49 @@ class TouchObject(BaseItem):
def set_selected(self, selected): def set_selected(self, selected):
self.selected = selected self.selected = selected
def render(self, surface):
if self.selected:
surface.blit(self.selected_box, self.pos)
surface.blit(self.selected_box_rectangle, self.pos)
def pre_render(self, surface):
if self.selected:
surface.blit(self.selected_box, self.pos)
def post_render(self, surface):
if self.selected:
surface.blit(self.selected_box_rectangle, self.pos)
class TouchAndTextItem(TouchObject, TextItem): class TouchAndTextItem(TouchObject, TextItem):
def __init__(self, font, text, pos, size, center=False): def __init__(self, font, text, pos, size, center=False):
TextItem.__init__(self, font, text, pos, size, center=center) TextItem.__init__(self, font, text, pos, size, center=center)
TouchObject.__init__(self, pos, self.size) TouchObject.__init__(self, pos, self.size)
self.active_color = (0, 150, 255) self.active_color = (0, 150, 255)
self.selected_color = (150, 0, 255) self.normal_box = self.box
self.active_box = self.font.render(text, True, self.active_box = self.font.render(text, True,
self.active_color) self.active_color)
self.selected_box = self.font.render(text, True,
self.selected_color)
def update(self): def update(self):
TextItem.update(self) TextItem.update(self)
def set_text(self, text, change_size): def set_text(self, text, change_size):
TextItem.set_text(self, text, change_size) TextItem.set_text(self, text, change_size)
self.normal_box = self.box
self.active_box = self.font.render(text, True, self.active_box = self.font.render(text, True,
self.active_color) self.active_color)
self.selected_box = self.font.render(text, True,
self.selected_color) def set_active(self, active):
TouchObject.set_active(self, active)
if self.active:
self.box = self.active_box
else:
self.box = self.normal_box
def render(self, surface): def render(self, surface):
if not self.fit_horizontal: TouchObject.pre_render(self, surface)
self.rect = pygame.Rect(self.step, 0, self.size[0], TextItem.render(self, surface)
self.size[1]) TouchObject.post_render(self, surface)
if self.selected:
surface.blit(self.selected_box, (self.pos[0]+self.margin, self.pos[1]), area=self.rect)
elif self.active:
surface.blit(self.active_box, (self.pos[0]+self.margin, self.pos[1]), area=self.rect)
else:
surface.blit(self.box, (self.pos[0]+self.margin, self.pos[1]), area=self.rect)
class Progressbar(TouchObject): class Progressbar(TouchObject):
@@ -336,24 +245,33 @@ class Progressbar(TouchObject):
self.max = max_value self.max = max_value
self.back_color = (0, 0, 0, 128) self.back_color = (0, 0, 0, 128)
self.main_color = (0, 150, 255) 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.surface.fill(self.back_color)
self.value_text = value_text self.value_text = value_text
if value_text: if value_text:
self.text = TextItem(font, str(max_value), pos, None) self.text = TextItem(font, str(max_value), pos, None)
self.text.pos = ( self.text.pos = (self.pos[0]
self.pos[0] + self.size[0] / 2 - self.text.size[0] / + self.size[0] / 2 -
2, self.text.pos[1]) self.text.size[0] /
2, self.text.pos[1])
self.text.set_text(str(self.value), True) self.text.set_text(str(self.value), True)
else: else:
self.text = TextItem(font, text, pos, None) self.text = TextItem(font, text, pos, None)
self.text.pos = ( self.text.pos = (
self.pos[0] + self.size[0] / 2 - self.text.size[0] / self.pos[0] + self.size[0] / 2 - self.text.size[0] /
2, self.text.pos[1]) 2, self.text.pos[1])
# Rectangle
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)
def render(self, surface): def render(self, surface):
surface.blit(self.surface, self.pos) surface.blit(self.surface, self.pos)
surface.blit(self.rectangle, self.pos)
self.text.render(surface) self.text.render(surface)
def set_value(self, value): def set_value(self, value):
@@ -361,9 +279,10 @@ class Progressbar(TouchObject):
self.value = value self.value = value
if self.value_text: if self.value_text:
self.set_text(str(self.value)) self.set_text(str(self.value))
self.text.pos = ( self.text.pos = (self.pos[0]
self.pos[0] + self.size[0] / 2 - self.text.size[0] / + self.size[0] / 2 -
2, self.text.pos[1]) self.text.size[0]
/ 2, self.text.pos[1])
self.surface.fill(self.back_color) self.surface.fill(self.back_color)
pos_pixel = value * self.size[0] / self.max pos_pixel = value * self.size[0] / self.max
rect = pygame.Rect(0, 0, pos_pixel, self.size[1]) rect = pygame.Rect(0, 0, pos_pixel, self.size[1])
@@ -386,7 +305,8 @@ class ScrollBar(TouchObject):
self.max = max_value self.max = max_value
self.items_on_screen = items_on_screen self.items_on_screen = items_on_screen
self.current_item = 0 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.back_bar.fill((255, 255, 255, 128))
self.bar_pos = 0 self.bar_pos = 0
if self.max < 1: if self.max < 1:
@@ -395,7 +315,7 @@ class ScrollBar(TouchObject):
self.bar_size = math.ceil( self.bar_size = math.ceil(
float(self.items_on_screen) / float(self.max) * float( float(self.items_on_screen) / float(self.max) * float(
self.size[1])) 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)) self.bar.fill((255, 255, 255))
def render(self, surface): def render(self, surface):

2
mopidy_touchscreen/input/__init__.py Normal file
View File

@@ -0,0 +1,2 @@
# flake8: noqa
from input_manager import InputManager

8
mopidy_touchscreen/gpio_inpput_manager.py → mopidy_touchscreen/input/gpio_inpput_manager.py
View File

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

16
mopidy_touchscreen/input_manager.py → mopidy_touchscreen/input/input_manager.py
View File

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

92
mopidy_touchscreen/menu_screen.py
View File

@@ -1,92 +0,0 @@
import os
import socket
import mopidy
from .screen_objects import ScreenObjectsManager, TouchAndTextItem
from .input_manager import InputManager
from .base_screen import BaseScreen
class MenuScreen(BaseScreen):
def __init__(self, size, base_size, manager, fonts):
BaseScreen.__init__(self, size, base_size, manager, fonts)
self.ip = None
self.screen_objects = ScreenObjectsManager()
# Exit mopidy button
button = TouchAndTextItem(self.manager.fonts['icon'],
u"\ue611",
(0, 0), None)
self.screen_objects.set_touch_object("exit_icon", button)
button = TouchAndTextItem(self.fonts['base'],
"Exit Mopidy",
(button.get_right_pos(),
0),
None)
self.screen_objects.set_touch_object("exit", button)
# Shutdown button
button = TouchAndTextItem(self.fonts['icon'],
u"\ue60b",
(0, self.base_size * 1), None)
self.screen_objects.set_touch_object("shutdown_icon", button)
button = TouchAndTextItem(self.fonts['base'],
"Shutdown",
(button.get_right_pos(),
self.base_size * 1),
None)
self.screen_objects.set_touch_object("shutdown", button)
# Restart button
button = TouchAndTextItem(self.fonts['icon'],
u"\ue609",
(0, self.base_size * 2), None)
self.screen_objects.set_touch_object("restart_icon", button)
button = TouchAndTextItem(self.fonts['base'],
"Restart",
(button.get_right_pos(),
self.base_size * 2),
None)
self.screen_objects.set_touch_object("restart", button)
# IP addres
button = TouchAndTextItem(self.fonts['base'], "IP: ",
(0, self.base_size * 3), None)
self.screen_objects.set_touch_object("ip", button)
def update(self, screen, update_all):
self.screen_objects.render(screen)
def touch_event(self, event):
if event.type == InputManager.click:
clicked = self.screen_objects.get_touch_objects_in_pos(
event.current_pos)
for key in clicked:
if key == "exit_icon" or key == "exit":
mopidy.utils.process.exit_process()
elif key == "shutdown_icon" or key == "shutdown":
if os.system("gksu -- shutdown now -h") != 0:
os.system("shutdown now -h")
elif key == "restart_icon" or key == "restart":
if os.system("gksu -- shutdown -r now") != 0:
os.system("shutdown -r now")
elif key == "ip":
self.check_connection()
# Will check internet connection
def check_connection(self):
try:
self.manager.set_connection(False, True)
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
self.ip = s.getsockname()[0]
s.close()
self.screen_objects.get_touch_object("ip").set_text(
"IP: " + self.ip, "None")
self.manager.set_connection(True, False)
except socket.error:
s.close()
self.ip = None
self.screen_objects.get_touch_object("ip").set_text(
"IP: No internet", "None")
self.manager.set_connection(False, False)

92
mopidy_touchscreen/screen_manager.py
View File

@@ -1,18 +1,17 @@
import logging import logging
import traceback import traceback
import pygame
from graphic_utils import DynamicBackground, \
ScreenObjectsManager, TouchAndTextItem
from input import InputManager
from pkg_resources import Requirement, resource_filename from pkg_resources import Requirement, resource_filename
from .search_screen import SearchScreen import pygame
from .library_screen import LibraryScreen
from .main_screen import MainScreen from screens import LibraryScreen, MainScreen, MenuScreen,\
from .menu_screen import MenuScreen PlaylistScreen, SearchScreen, Tracklist
from .playlist_screen import PlaylistScreen
from .screen_objects import ScreenObjectsManager, \
TouchAndTextItem
from .input_manager import InputManager
from .tracklist import Tracklist
from .dynamic_background import DynamicBackground
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@@ -29,41 +28,49 @@ class ScreenManager():
self.core = core self.core = core
self.cache = cache self.cache = cache
self.fonts = {} self.fonts = {}
self.background = None
self.current_screen = library_index self.current_screen = library_index
self.init_manager(size)
# Init variables in init
self.base_size = None
self.size = None
self.screens = None
self.track = None
self.input_manager = InputManager(size)
self.down_bar_objects = ScreenObjectsManager()
self.down_bar = None
self.init_manager(size)
def init_manager(self, size): def init_manager(self, size):
self.size = size self.size = size
self.background = DynamicBackground(self.size) self.background = DynamicBackground(self.size)
self.current_screen = 0
self.base_size = self.size[1] / 8 self.base_size = self.size[1] / 8
font = resource_filename( font = resource_filename(
Requirement.parse("mopidy-touchscreen"), Requirement.parse("mopidy-touchscreen"),
"mopidy_touchscreen/icomoon.ttf") "mopidy_touchscreen/icomoon.ttf")
self.fonts['base'] = pygame.font.SysFont("verdana", self.fonts['base'] = pygame.font.SysFont("arial",
self.base_size) self.base_size)
self.fonts['icon'] = pygame.font.Font(font, self.base_size) self.fonts['icon'] = pygame.font.Font(font, self.base_size)
try: try:
self.screens = [ self.screens = [
SearchScreen(size, self.base_size, self, self.fonts), SearchScreen(size, self.base_size, self, self.fonts),
MainScreen(size, self.base_size, self, self.fonts, self.cache, self.core, self.background), MainScreen(size, self.base_size, self, self.fonts,
self.cache, self.core, self.background),
Tracklist(size, self.base_size, self, self.fonts), Tracklist(size, self.base_size, self, self.fonts),
LibraryScreen(size, self.base_size, self, self.fonts), LibraryScreen(size, self.base_size, self, self.fonts),
PlaylistScreen(size, self.base_size, self, self.fonts), PlaylistScreen(size,
self.base_size, self, self.fonts),
MenuScreen(size, self.base_size, self, self.fonts)] MenuScreen(size, self.base_size, self, self.fonts)]
except: except:
traceback.print_exc() traceback.print_exc()
self.track = None self.track = None
self.input_manager = InputManager(size)
self.down_bar_objects = ScreenObjectsManager()
self.screen_changed = True
# Menu buttons # Menu buttons
button_size = (self.size[0] / 6, self.base_size) button_size = (self.size[0] / 6, self.base_size)
# Search button # Search button
button = TouchAndTextItem(self.fonts['icon'], u" \ue986", button = TouchAndTextItem(self.fonts['icon'], u" \ue986",
(0, self.base_size * 7), (0, self.base_size * 7),
button_size, center=True) button_size, center=True)
@@ -101,14 +108,16 @@ class ScreenManager():
# Menu button # Menu button
button = TouchAndTextItem(self.fonts['icon'], u" \ue60a", button = TouchAndTextItem(self.fonts['icon'], u" \ue60a",
(x, self.base_size * 7), button_size, center=True) (x, self.base_size * 7),
button_size,
center=True)
self.down_bar_objects.set_touch_object("menu_5", button) self.down_bar_objects.set_touch_object("menu_5", button)
# Down bar # Down bar
self.down_bar = pygame.Surface( self.down_bar = pygame.Surface(
(self.size[0], self.size[1] - self.base_size * 7), (self.size[0], self.size[1] - self.base_size * 7),
pygame.SRCALPHA) pygame.SRCALPHA)
self.down_bar.fill((0, 0, 0, 128)) self.down_bar.fill((0, 0, 0, 200))
self.options_changed() self.options_changed()
self.mute_changed(self.core.playback.mute.get()) self.mute_changed(self.core.playback.mute.get())
@@ -118,13 +127,10 @@ class ScreenManager():
self.change_screen(self.current_screen) self.change_screen(self.current_screen)
def update(self): def update(self):
surface = pygame.Surface(self.size) surface = self.background.draw_background()
self.background.draw_background(surface) self.screens[self.current_screen].update(surface)
self.screens[self.current_screen].update(surface,
self.screen_changed)
surface.blit(self.down_bar, (0, self.base_size * 7)) surface.blit(self.down_bar, (0, self.base_size * 7))
self.down_bar_objects.render(surface) self.down_bar_objects.render(surface)
self.screen_changed = False
return surface return surface
def track_started(self, track): def track_started(self, track):
@@ -133,7 +139,8 @@ class ScreenManager():
self.screens[tracklist_index].track_started(track) self.screens[tracklist_index].track_started(track)
def track_playback_ended(self, tl_track, time_position): def track_playback_ended(self, tl_track, time_position):
self.screens[main_screen_index].track_playback_ended(tl_track, time_position) self.screens[main_screen_index].track_playback_ended(
tl_track, time_position)
def event(self, event): def event(self, event):
event = self.input_manager.event(event) event = self.input_manager.event(event)
@@ -143,16 +150,26 @@ class ScreenManager():
def manage_event(self, event): def manage_event(self, event):
if event.type == InputManager.click: if event.type == InputManager.click:
objects = self.down_bar_objects.get_touch_objects_in_pos(event.current_pos) objects = \
self.down_bar_objects.get_touch_objects_in_pos(
event.current_pos)
return self.click_on_objects(objects, event) return self.click_on_objects(objects, event)
else: else:
if event.type == InputManager.key:
if event.direction == InputManager.right:
self.change_screen(self.current_screen+1)
return True
elif event.direction == InputManager.left:
self.change_screen(self.current_screen-1)
return True
return False return False
def volume_changed(self, volume): def volume_changed(self, volume):
self.screens[main_screen_index].volume_changed(volume) self.screens[main_screen_index].volume_changed(volume)
def playback_state_changed(self, old_state, new_state): def playback_state_changed(self, old_state, new_state):
self.screens[main_screen_index].playback_state_changed(old_state, new_state) self.screens[main_screen_index].playback_state_changed(
old_state, new_state)
def mute_changed(self, mute): def mute_changed(self, mute):
self.screens[main_screen_index].mute_changed(mute) self.screens[main_screen_index].mute_changed(mute)
@@ -164,12 +181,12 @@ class ScreenManager():
self.screens[main_screen_index].options_changed() self.screens[main_screen_index].options_changed()
def change_screen(self, new_screen): def change_screen(self, new_screen):
self.screen_changed = True if new_screen > -1 and new_screen < len(self.screens):
self.down_bar_objects.get_touch_object( self.down_bar_objects.get_touch_object(
"menu_" + str(self.current_screen)).set_active(False) "menu_" + str(self.current_screen)).set_active(False)
self.current_screen = new_screen self.current_screen = new_screen
self.down_bar_objects.get_touch_object( self.down_bar_objects.get_touch_object(
"menu_" + str(new_screen)).set_active(True) "menu_" + str(new_screen)).set_active(True)
def click_on_objects(self, objects, event): def click_on_objects(self, objects, event):
if objects is not None: if objects is not None:
@@ -183,7 +200,8 @@ class ScreenManager():
self.screens[playlist_index].playlists_loaded() self.screens[playlist_index].playlists_loaded()
def set_connection(self, connection, loading): def set_connection(self, connection, loading):
self.screens[main_screen_index].set_connection(connection, loading) self.screens[main_screen_index].set_connection(connection,
loading)
def check_connection(self): def check_connection(self):
self.screens[menu_index].check_connection() self.screens[menu_index].check_connection()

7
mopidy_touchscreen/screens/__init__.py Normal file
View File

@@ -0,0 +1,7 @@
# flake8: noqa
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 tracklist import Tracklist

3
mopidy_touchscreen/base_screen.py → mopidy_touchscreen/screens/base_screen.py
View File

@@ -1,6 +1,3 @@
__author__ = 'ander'
class BaseScreen(): class BaseScreen():
def __init__(self, size, base_size, manager, fonts): def __init__(self, size, base_size, manager, fonts):

40
mopidy_touchscreen/library_screen.py → mopidy_touchscreen/screens/library_screen.py
View File

@@ -1,29 +1,22 @@
import logging from base_screen import BaseScreen
import mopidy.models import mopidy.models
from .list_view import ListView from ..graphic_utils import ListView
from .input_manager import InputManager
from .base_screen import BaseScreen
logger = logging.getLogger(__name__)
class LibraryScreen(BaseScreen): class LibraryScreen(BaseScreen):
def __init__(self, size, base_size, manager, fonts): def __init__(self, size, base_size, manager, fonts):
BaseScreen.__init__(self, size, base_size, manager, fonts) BaseScreen.__init__(self, size, base_size, manager, fonts)
self.list_view = ListView((0, 0), ( 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.directory_list = []
self.current_directory = None self.current_directory = None
self.library = None self.library = None
self.library_strings = None self.library_strings = None
self.browse_uri(None) self.browse_uri(None)
def get_dirty_area(self):
return self.list_view.get_dirty_area()
def go_inside_directory(self, uri): def go_inside_directory(self, uri):
self.directory_list.append(self.current_directory) self.directory_list.append(self.current_directory)
self.current_directory = uri self.current_directory = uri
@@ -44,7 +37,7 @@ class LibraryScreen(BaseScreen):
self.current_directory = directory self.current_directory = directory
self.browse_uri(directory) self.browse_uri(directory)
def update(self, screen, update_all): def update(self, screen):
self.list_view.render(screen) self.list_view.render(screen)
def touch_event(self, touch_event): def touch_event(self, touch_event):
@@ -54,24 +47,25 @@ class LibraryScreen(BaseScreen):
if clicked == 0: if clicked == 0:
self.go_up_directory() self.go_up_directory()
else: else:
if self.library[ if self.library[clicked - 1].type\
clicked - 1].type == mopidy.models.Ref.TRACK: == mopidy.models.Ref.TRACK:
self.play_uri(self.current_directory, clicked-1) self.play_uri(clicked-1)
else: else:
self.go_inside_directory( self.go_inside_directory(
self.library[clicked - 1].uri) self.library[clicked - 1].uri)
else: else:
self.go_inside_directory( self.go_inside_directory(self.library[clicked].uri)
self.library[clicked].uri)
def play_uri(self, uri, track_pos): def play_uri(self, track_pos):
self.manager.core.tracklist.clear() self.manager.core.tracklist.clear()
tracks = [] tracks = []
for item in self.library: for item in self.library:
if item.type == mopidy.models.Ref.TRACK: 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: else:
track_pos = track_pos - 1 track_pos -= 1
self.manager.core.tracklist.add(tracks) self.manager.core.tracklist.add(tracks)
self.manager.core.playback.play(tl_track=self.manager.core.tracklist.tl_tracks.get()[track_pos]) self.manager.core.playback.play(
tl_track=self.manager.core.tracklist.tl_tracks.get()
[track_pos])

152
mopidy_touchscreen/main_screen.py → mopidy_touchscreen/screens/main_screen.py
View File

@@ -3,24 +3,28 @@ import json
import logging import logging
import os import os
import time import time
import mopidy.core
import urllib import urllib
import urllib2 import urllib2
from threading import Thread from threading import Thread
import pygame
from .base_screen import BaseScreen
from .screen_objects import (Progressbar, ScreenObjectsManager,
TextItem, from base_screen import BaseScreen
TouchAndTextItem)
from .input_manager import InputManager import mopidy.core
import pygame
from ..graphic_utils import Progressbar, \
ScreenObjectsManager, TouchAndTextItem
from ..input import InputManager
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
class MainScreen(BaseScreen): class MainScreen(BaseScreen):
def __init__(self, size, base_size, manager, fonts, cache, core, background): def __init__(self, size, base_size, manager, fonts, cache, core,
background):
BaseScreen.__init__(self, size, base_size, manager, fonts) BaseScreen.__init__(self, size, base_size, manager, fonts)
self.core = core self.core = core
self.track = None self.track = None
@@ -36,7 +40,6 @@ class MainScreen(BaseScreen):
else: else:
self.track_started(current_track) self.track_started(current_track)
# Top bar # Top bar
self.top_bar = pygame.Surface((self.size[0], self.base_size), self.top_bar = pygame.Surface((self.size[0], self.base_size),
pygame.SRCALPHA) pygame.SRCALPHA)
@@ -85,7 +88,7 @@ class MainScreen(BaseScreen):
self.touch_text_manager.set_touch_object("volume", progress) self.touch_text_manager.set_touch_object("volume", progress)
progress.set_value(self.core.playback.volume.get()) progress.set_value(self.core.playback.volume.get())
def update(self, screen, update_all): def update(self, screen):
screen.blit(self.top_bar, (0, 0)) screen.blit(self.top_bar, (0, 0))
if self.track is not None: if self.track is not None:
self.touch_text_manager.get_touch_object( self.touch_text_manager.get_touch_object(
@@ -94,10 +97,12 @@ class MainScreen(BaseScreen):
self.touch_text_manager.get_touch_object( self.touch_text_manager.get_touch_object(
"time_progress").set_text( "time_progress").set_text(
time.strftime('%M:%S', time.gmtime( time.strftime('%M:%S', time.gmtime(
self.core.playback.time_position.get() / 1000)) + "/" + self.track_duration) self.core.playback.time_position.get() / 1000)) +
"/" + self.track_duration)
if self.image is not None: if self.image is not None:
screen.blit(self.image, ( screen.blit(self.image, (
self.base_size / 2, self.base_size + self.base_size / 2)) self.base_size / 2, self.base_size +
self.base_size / 2))
self.touch_text_manager.render(screen) self.touch_text_manager.render(screen)
return screen return screen
@@ -116,22 +121,22 @@ class MainScreen(BaseScreen):
# Track name # Track name
label = TouchAndTextItem(self.fonts['base'], label = TouchAndTextItem(self.fonts['base'],
MainScreen.get_track_name(track), MainScreen.get_track_name(track),
(x, self.base_size * 2), (x, self.base_size * 2), (width, -1))
(width, -1))
self.touch_text_manager.set_touch_object("track_name", label) self.touch_text_manager.set_touch_object("track_name", label)
# Album name # Album name
label = TouchAndTextItem(self.fonts['base'], label = TouchAndTextItem(self.fonts['base'],
MainScreen.get_track_album_name(track), MainScreen.get_track_album_name
(x, self.base_size * 3), (track), (x, self.base_size * 3),
(width, -1)) (width, -1))
self.touch_text_manager.set_touch_object("album_name", label) self.touch_text_manager.set_touch_object("album_name", label)
# Artist # Artist
label = TouchAndTextItem(self.fonts['base'], self.get_artist_string(), label = TouchAndTextItem(self.fonts['base'],
(x, self.base_size * 4), self.get_artist_string(),
(width, -1)) (x, self.base_size * 4),
(width, -1))
self.touch_text_manager.set_touch_object("artist_name", label) self.touch_text_manager.set_touch_object("artist_name", label)
# Previous track button # Previous track button
@@ -150,9 +155,8 @@ class MainScreen(BaseScreen):
# Progress # Progress
progress = Progressbar(self.fonts['base'], progress = Progressbar(self.fonts['base'],
time.strftime('%M:%S', time.gmtime( time.strftime('%M:%S', time.gmtime(
0)) + "/" + time.strftime('%M:%S', 0)) + "/" + time.strftime(
time.gmtime( '%M:%S', time.gmtime(0)),
0)),
(size_1, self.base_size * 6), (size_1, self.base_size * 6),
( (
self.size[0] - size_1 - size_2, self.size[0] - size_1 - size_2,
@@ -220,72 +224,80 @@ class MainScreen(BaseScreen):
logger.info("Cover could not be downloaded") logger.info("Cover could not be downloaded")
# There is no cover so it will use all the screen size for the text # There is no cover
# so it will use all the screen size for the text
width = self.size[0] - self.base_size width = self.size[0] - self.base_size
current = TouchAndTextItem(self.fonts['base'], current = TouchAndTextItem(self.fonts['base'],
MainScreen.get_track_name(self.track), MainScreen.get_track_name
(self.base_size / 2, (self.track),
self.base_size * 2), (self.base_size / 2,
(width, -1)) self.base_size * 2),
self.touch_text_manager.set_touch_object("track_name", current) (width, -1))
self.touch_text_manager.set_touch_object("track_name",
current)
current = TouchAndTextItem(self.fonts['base'], current = TouchAndTextItem(self.fonts['base'],
MainScreen.get_track_album_name( MainScreen.get_track_album_name
self.track), (self.track),
(self.base_size / 2, (self.base_size / 2,
self.base_size * 3), self.base_size * 3),
(width, -1)) (width, -1))
self.touch_text_manager.set_touch_object("album_name", current) self.touch_text_manager.set_touch_object("album_name",
current)
current = TouchAndTextItem(self.fonts['base'], current = TouchAndTextItem(self.fonts['base'],
self.get_artist_string(), self.get_artist_string(),
(self.base_size / 2, (self.base_size / 2,
self.base_size * 4), self.base_size * 4),
(width, -1)) (width, -1))
self.touch_text_manager.set_touch_object("artist_name", current) self.touch_text_manager.set_touch_object("artist_name",
current)
def track_playback_ended(self, tl_track, time_position): def track_playback_ended(self, tl_track, time_position):
if self.image is not None: self.background.set_target_color(None, None)
self.dirty_area.append(pygame.Rect(self.base_size / 2, self.image = None
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"
width = self.size[0] - self.base_size width = self.size[0] - self.base_size
current = TouchAndTextItem(self.fonts['base'], "", current = TouchAndTextItem(self.fonts['base'], "",
(self.base_size / 2, self.base_size * 2), (self.base_size / 2,
(width, -1)) self.base_size * 2),
self.touch_text_manager.set_touch_object("track_name", current) (width, -1))
self.touch_text_manager.set_touch_object("track_name",
current)
current = TouchAndTextItem(self.fonts['base'], "", current = TouchAndTextItem(self.fonts['base'], "",
(self.base_size / 2, self.base_size * 3), (self.base_size / 2,
(width, -1)) self.base_size * 3),
self.touch_text_manager.set_touch_object("album_name", current) (width, -1))
self.touch_text_manager.set_touch_object("album_name",
current)
current = TouchAndTextItem(self.fonts['base'], "", current = TouchAndTextItem(self.fonts['base'], "",
(self.base_size / 2, self.base_size * 4), (self.base_size / 2,
(width, -1)) self.base_size * 4),
self.touch_text_manager.set_touch_object("artist_name", current) (width, -1))
self.touch_text_manager.set_touch_object("artist_name",
current)
def load_image(self): def load_image(self):
size = self.base_size * 4 size = self.base_size * 4
image = pygame.transform.scale(pygame.image.load( image_original = pygame.image.load(
self.get_cover_folder() + self.get_cover_folder() +
self.get_image_file_name()).convert(), self.get_image_file_name())
(size, size)) image = pygame.transform.scale(image_original, (size, size))
self.background.set_target_color(pygame.transform.average_color(image), image) image = image.convert()
self.background.set_target_color(pygame.transform.average_color(image),
image_original)
self.image = image self.image = image
def touch_event(self, event): def touch_event(self, event):
if event.type == InputManager.click: if event.type == InputManager.click:
objects = self.touch_text_manager.get_touch_objects_in_pos( objects = \
event.current_pos) self.touch_text_manager.get_touch_objects_in_pos(
event.current_pos)
if objects is not None: if objects is not None:
self.click_on_objects(objects, event) self.click_on_objects(objects, event)
@@ -312,7 +324,7 @@ class MainScreen(BaseScreen):
for key in objects: for key in objects:
if key == "time_progress": if key == "time_progress":
value = self.touch_text_manager.get_touch_object( value = self.touch_text_manager.get_touch_object(
key).get_pos_value( key).get_pos_value(
event.current_pos) * 1000 event.current_pos) * 1000
self.core.playback.seek(value) self.core.playback.seek(value)
@@ -406,7 +418,8 @@ class MainScreen(BaseScreen):
"pause_play").set_text(u"\ue615", False) "pause_play").set_text(u"\ue615", False)
def set_connection(self, connection, loading): def set_connection(self, connection, loading):
internet = self.touch_text_manager.get_touch_object("internet") internet = self.touch_text_manager.get_touch_object(
"internet")
if loading: if loading:
internet.set_text(u"\ue627", None) internet.set_text(u"\ue627", None)
internet.set_active(False) internet.set_active(False)
@@ -414,7 +427,6 @@ class MainScreen(BaseScreen):
internet.set_text(u"\ue602", None) internet.set_text(u"\ue602", None)
internet.set_active(connection) internet.set_active(connection)
@staticmethod @staticmethod
def get_track_name(track): def get_track_name(track):
if track.name is None: if track.name is None:
@@ -424,8 +436,8 @@ class MainScreen(BaseScreen):
@staticmethod @staticmethod
def get_track_album_name(track): def get_track_album_name(track):
if track.album is not None and track.album.name is not None and len( if track.album is not None and track.album.name is not None\
track.album.name) > 0: and len(track.album.name) > 0:
return track.album.name return track.album.name
else: else:
return "Unknow Album" return "Unknow Album"

54
mopidy_touchscreen/screens/menu_screen.py Normal file
View File

@@ -0,0 +1,54 @@
import os
import socket
from base_screen import BaseScreen
import mopidy
from ..graphic_utils import ListView
class MenuScreen(BaseScreen):
def __init__(self, size, base_size, manager, fonts):
BaseScreen.__init__(self, size, base_size, manager, fonts)
self.ip = None
self.list = ListView((0, 0), size, base_size, fonts['base'])
self.list_items = ["Exit Mopidy", "Shutdown", "Restart", "IP: "]
self.list.set_list(self.list_items)
def update(self, screen):
self.list.render(screen)
def touch_event(self, event):
clicked = self.list.touch_event(event)
if clicked is not None:
if clicked == 0:
mopidy.utils.process.exit_process()
elif clicked == 1:
if os.system("gksu -- shutdown now -h") != 0:
os.system("sudo shutdown now -h")
elif clicked == 2:
if os.system("gksu -- shutdown -r now") != 0:
os.system("sudo shutdown -r now")
elif clicked == 3:
self.check_connection()
# Will check internet connection
def check_connection(self):
try:
self.manager.set_connection(False, True)
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
self.ip = s.getsockname()[0]
s.close()
self.list_items[3] = "IP: " + self.ip
self.list.set_list(self.list_items)
self.manager.set_connection(True, False)
except socket.error:
s.close()
self.ip = None
self.list_items[2] = "IP: No internet"
self.list.set_list(self.list_items)
self.manager.set_connection(False, False)

28
mopidy_touchscreen/playlist_screen.py → mopidy_touchscreen/screens/playlist_screen.py
View File

@@ -1,14 +1,15 @@
from .list_view import ListView from base_screen import BaseScreen
from .base_screen import BaseScreen
from ..graphic_utils import ListView
class PlaylistScreen(BaseScreen): class PlaylistScreen(BaseScreen):
def __init__(self, size, base_size, manager, fonts): def __init__(self, size, base_size, manager, fonts):
BaseScreen.__init__(self, size, base_size, manager, fonts) BaseScreen.__init__(self, size, base_size, manager, fonts)
self.list_view = ListView((0, 0), ( 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.playlists_strings = [] self.playlists_strings = []
self.playlists = [] self.playlists = []
self.playlists_loaded() self.playlists_loaded()
@@ -16,7 +17,7 @@ class PlaylistScreen(BaseScreen):
self.playlist_tracks = [] self.playlist_tracks = []
self.playlist_tracks_strings = [] self.playlist_tracks_strings = []
def update(self, screen, update_all): def update(self, screen):
self.list_view.render(screen) self.list_view.render(screen)
def playlists_loaded(self): def playlists_loaded(self):
@@ -36,21 +37,20 @@ class PlaylistScreen(BaseScreen):
self.playlist_tracks_strings.append(track.name) self.playlist_tracks_strings.append(track.name)
self.list_view.set_list(self.playlist_tracks_strings) self.list_view.set_list(self.playlist_tracks_strings)
def touch_event(self, touch_event): def touch_event(self, touch_event):
clicked = self.list_view.touch_event(touch_event) clicked = self.list_view.touch_event(touch_event)
if clicked is not None: if clicked is not None:
if self.selected_playlist is None: if self.selected_playlist is None:
self.playlist_selected(self.playlists[clicked]) self.playlist_selected(self.playlists[clicked])
else: else:
if clicked==0: if clicked == 0:
self.selected_playlist = None self.selected_playlist = None
self.list_view.set_list(self.playlists_strings) self.list_view.set_list(self.playlists_strings)
else: else:
self.manager.core.tracklist.clear() self.manager.core.tracklist.clear()
self.manager.core.tracklist.add(self.playlist_tracks) self.manager.core.tracklist.add(
self.manager.core.playback.play(tl_track=self.manager.core.tracklist.tl_tracks.get()[clicked-1]) self.playlist_tracks)
#self.manager.core.tracklist.clear() self.manager.core.playback.play(
#self.manager.core.tracklist.add( tl_track=self.manager.core.
# uri=self.playlists[clicked].uri) tracklist.tl_tracks.get()
#self.manager.core.playback.play() [clicked-1])

54
mopidy_touchscreen/search_screen.py → mopidy_touchscreen/screens/search_screen.py
View File

@@ -1,15 +1,11 @@
from .list_view import ListView from base_screen import BaseScreen
import logging
import pygame import pygame
from .screen_objects import Progressbar, ScreenObjectsManager, \ from ..graphic_utils import ListView,\
TouchAndTextItem, TextItem ScreenObjectsManager, TextItem, TouchAndTextItem
from .base_screen import BaseScreen
from .input_manager import InputManager
logger = logging.getLogger(__name__)
from ..input import InputManager
mode_track_name = 0 mode_track_name = 0
mode_album_name = 1 mode_album_name = 1
@@ -20,40 +16,43 @@ class SearchScreen(BaseScreen):
def __init__(self, size, base_size, manager, fonts): def __init__(self, size, base_size, manager, fonts):
BaseScreen.__init__(self, size, base_size, manager, fonts) BaseScreen.__init__(self, size, base_size, manager, fonts)
self.list_view = ListView((0, self.base_size*2), ( self.list_view = ListView((0, self.base_size*2), (
self.size[0], self.size[1] - 3*self.base_size), self.size[0], self.size[1] -
self.base_size, 3*self.base_size), self.base_size, manager.fonts['base'])
manager.fonts['base'])
self.results_strings = [] self.results_strings = []
self.results = [] self.results = []
self.screen_objects = ScreenObjectsManager() self.screen_objects = ScreenObjectsManager()
self.query = "" self.query = ""
# Query text # Query text
text = TextItem(self.fonts['base'],self.query, (0, 0), (self.size[0], self.base_size), center=True) text = TextItem(self.fonts['base'], self.query, (0, 0),
(self.size[0], self.base_size), center=True)
self.screen_objects.set_object("query", text) self.screen_objects.set_object("query", text)
# Mode buttons # Mode buttons
button_size = (self.size[0] / 3, self.base_size) button_size = (self.size[0] / 3, self.base_size)
self.mode_objects_keys = ["mode_track", "mode_album", "mode_artist"] self.mode_objects_keys = ["mode_track", "mode_album",
"mode_artist"]
# Track button # Track button
button = TouchAndTextItem(self.fonts['base'], "Track", button = TouchAndTextItem(self.fonts['base'], "Track",
(0, self.base_size), (0, self.base_size),
button_size, center=True) button_size, center=True)
self.screen_objects.set_touch_object(self.mode_objects_keys[0], button) self.screen_objects.set_touch_object(
self.mode_objects_keys[0], button)
# Album button # Album button
button = TouchAndTextItem(self.fonts['base'], "Album", button = TouchAndTextItem(self.fonts['base'], "Album",
(button_size[0], self.base_size), (button_size[0], self.base_size),
button_size, center=True) button_size, center=True)
self.screen_objects.set_touch_object(self.mode_objects_keys[1], button) self.screen_objects.set_touch_object(
self.mode_objects_keys[1], button)
# Artist button # Artist button
button = TouchAndTextItem(self.fonts['base'], "Artist", button = TouchAndTextItem(self.fonts['base'], "Artist",
(button_size[0]*2, self.base_size), (button_size[0]*2, self.base_size),
button_size, center=True) button_size, center=True)
self.screen_objects.set_touch_object(self.mode_objects_keys[2], button) self.screen_objects.set_touch_object(
self.mode_objects_keys[2], button)
# Top Bar # Top Bar
self.top_bar = pygame.Surface( self.top_bar = pygame.Surface(
@@ -65,7 +64,7 @@ class SearchScreen(BaseScreen):
self.set_mode(mode=mode_track_name) self.set_mode(mode=mode_track_name)
self.set_query("") self.set_query("")
def update(self, screen, update_all): def update(self, screen):
screen.blit(self.top_bar, (0, 0)) screen.blit(self.top_bar, (0, 0))
self.screen_objects.render(screen) self.screen_objects.render(screen)
self.list_view.render(screen) self.list_view.render(screen)
@@ -74,12 +73,15 @@ class SearchScreen(BaseScreen):
if mode is not self.mode: if mode is not self.mode:
self.mode = mode self.mode = mode
for key in self.mode_objects_keys: for key in self.mode_objects_keys:
self.screen_objects.get_touch_object(key).set_active(False) self.screen_objects.get_touch_object(key).\
self.screen_objects.get_touch_object(self.mode_objects_keys[self.mode]).set_active(True) set_active(False)
self.screen_objects.get_touch_object(
self.mode_objects_keys[self.mode]).set_active(True)
def set_query(self, query=""): def set_query(self, query=""):
self.query = query self.query = query
self.screen_objects.get_object("query").set_text(self.query, False) self.screen_objects.get_object("query").set_text(
self.query, False)
def search(self, query=None, mode=None): def search(self, query=None, mode=None):
if query is not None: if query is not None:
@@ -92,8 +94,9 @@ class SearchScreen(BaseScreen):
search_query = {'album': [self.query]} search_query = {'album': [self.query]}
else: else:
search_query = {'artist': [self.query]} search_query = {'artist': [self.query]}
if len(self.query)>0: if len(self.query) > 0:
current_results = self.manager.core.library.search(search_query).get() current_results = self.manager.core.library.search(
search_query).get()
self.results = [] self.results = []
self.results_strings = [] self.results_strings = []
for backend in current_results: for backend in current_results:
@@ -109,8 +112,6 @@ class SearchScreen(BaseScreen):
self.results_strings.append(result.name) self.results_strings.append(result.name)
self.list_view.set_list(self.results_strings) self.list_view.set_list(self.results_strings)
def touch_event(self, touch_event): def touch_event(self, touch_event):
if touch_event.type == InputManager.click: if touch_event.type == InputManager.click:
clicked = self.list_view.touch_event(touch_event) clicked = self.list_view.touch_event(touch_event)
@@ -120,7 +121,8 @@ class SearchScreen(BaseScreen):
uri=self.results[clicked].uri) uri=self.results[clicked].uri)
self.manager.core.playback.play() self.manager.core.playback.play()
else: else:
clicked = self.screen_objects.get_touch_objects_in_pos(touch_event.down_pos) clicked = self.screen_objects.get_touch_objects_in_pos(
touch_event.down_pos)
if len(clicked) > 0: if len(clicked) > 0:
clicked = clicked[0] clicked = clicked[0]
if clicked == self.mode_objects_keys[0]: if clicked == self.mode_objects_keys[0]:

17
mopidy_touchscreen/tracklist.py → mopidy_touchscreen/screens/tracklist.py
View File

@@ -1,6 +1,7 @@
from .list_view import ListView from base_screen import BaseScreen
from .main_screen import MainScreen from .main_screen import MainScreen
from .base_screen import BaseScreen from ..graphic_utils import ListView
class Tracklist(BaseScreen): class Tracklist(BaseScreen):
@@ -10,12 +11,15 @@ class Tracklist(BaseScreen):
self.base_size = base_size self.base_size = base_size
self.manager = manager self.manager = manager
self.list_view = ListView((0, 0), ( self.list_view = ListView((0, 0), (
self.size[0], self.size[1] - self.base_size), self.base_size, self.fonts['base']) self.size[0], self.size[1] -
self.base_size), self.base_size, self.fonts['base'])
self.tracks = [] self.tracks = []
self.tracks_strings = [] self.tracks_strings = []
self.update_list() self.update_list()
self.track_started(
self.manager.core.playback.current_tl_track.get())
def update(self, screen, update_all): def update(self, screen):
self.list_view.render(screen) self.list_view.render(screen)
def tracklist_changed(self): def tracklist_changed(self):
@@ -32,9 +36,8 @@ class Tracklist(BaseScreen):
def touch_event(self, touch_event): def touch_event(self, touch_event):
pos = self.list_view.touch_event(touch_event) pos = self.list_view.touch_event(touch_event)
if pos is not None: if pos is not None:
self.manager.core.playback.change_track(self.tracks[pos], self.manager.core.playback.play(self.tracks[pos])
on_error_step=1)
def track_started(self, track): def track_started(self, track):
self.list_view.set_selected( self.list_view.set_active(
[self.manager.core.tracklist.index(track).get()]) [self.manager.core.tracklist.index(track).get()])

38
mopidy_touchscreen/touch_screen.py
View File

@@ -1,11 +1,13 @@
import logging import logging
import os
import traceback import traceback
from threading import Thread from threading import Thread
import os
from mopidy import core, utils
import pygame import pygame
import pykka import pykka
import mopidy
from mopidy import core
from .screen_manager import ScreenManager from .screen_manager import ScreenManager
@@ -23,12 +25,20 @@ class TouchScreen(pykka.ThreadingActor, core.CoreListener):
self.fullscreen = config['touchscreen']['fullscreen'] self.fullscreen = config['touchscreen']['fullscreen']
self.screen_size = (config['touchscreen']['screen_width'], self.screen_size = (config['touchscreen']['screen_width'],
config['touchscreen']['screen_height']) config['touchscreen']['screen_height'])
os.environ["SDL_FBDEV"] = config['touchscreen']['sdl_fbdev']
os.environ["SDL_MOUSEDRV"] = config['touchscreen'][ if config['touchscreen']['sdl_fbdev'].lower() != "none":
'sdl_mousdrv'] os.environ["SDL_FBDEV"] = config['touchscreen']['sdl_fbdev']
os.environ["SDL_MOUSEDEV"] = config['touchscreen'][ if config['touchscreen']['sdl_mousdrv'].lower() != "none":
'sdl_mousedev'] os.environ["SDL_MOUSEDRV"] = (
os.environ["SDL_AUDIODRIVER"] = config['touchscreen']['sdl_audiodriver'] config['touchscreen']['sdl_mousdrv'])
if config['touchscreen']['sdl_mousedev'].lower() != "none":
os.environ["SDL_MOUSEDEV"] = config['touchscreen']['sdl_mousedev']
if config['touchscreen']['sdl_audiodriver'].lower() != "none":
os.environ["SDL_AUDIODRIVER"] = (
config['touchscreen']['sdl_audiodriver'])
os.environ["SDL_PATH_DSP"] = config['touchscreen']['sdl_path_dsp'] os.environ["SDL_PATH_DSP"] = config['touchscreen']['sdl_path_dsp']
pygame.init() pygame.init()
pygame.display.set_caption("Mopidy-Touchscreen") pygame.display.set_caption("Mopidy-Touchscreen")
@@ -38,11 +48,11 @@ class TouchScreen(pykka.ThreadingActor, core.CoreListener):
self.core, self.core,
self.cache_dir) self.cache_dir)
# Raspberry pi GPIO # Raspberry pi GPIO
self.gpio = config['touchscreen']['gpio'] self.gpio = config['touchscreen']['gpio']
if self.gpio: if self.gpio:
from .gpio_inpput_manager import GPIOManager
from input import GPIOManager
pins = {} pins = {}
pins['left'] = config['touchscreen']['gpio_left'] pins['left'] = config['touchscreen']['gpio_left']
@@ -54,8 +64,8 @@ class TouchScreen(pykka.ThreadingActor, core.CoreListener):
def get_display_surface(self, size): def get_display_surface(self, size):
if self.fullscreen: if self.fullscreen:
self.screen = pygame.display.set_mode(size, self.screen = pygame.display.set_mode(
pygame.FULLSCREEN) size, pygame.FULLSCREEN)
else: else:
self.screen = pygame.display.set_mode(size, pygame.RESIZABLE) self.screen = pygame.display.set_mode(size, pygame.RESIZABLE)
@@ -76,7 +86,7 @@ class TouchScreen(pykka.ThreadingActor, core.CoreListener):
else: else:
self.screen_manager.event(event) self.screen_manager.event(event)
pygame.quit() pygame.quit()
mopidy.utils.process.exit_process() utils.process.exit_process()
def on_start(self): def on_start(self):
try: try:

8
setup.py
View File

@@ -6,9 +6,9 @@ from setuptools import find_packages, setup
def get_version(filename): def get_version(filename):
content = open(filename).read() with open(filename) as fh:
metadata = dict(re.findall("__([a-z]+)__ = '([^']+)'", content)) metadata = dict(re.findall("__([a-z]+)__ = '([^']+)'", fh.read()))
return metadata['version'] return metadata['version']
setup( setup(
@@ -26,7 +26,7 @@ setup(
include_package_data=True, include_package_data=True,
install_requires=[ install_requires=[
'setuptools', 'setuptools',
'Mopidy >= 0.18', 'Mopidy >= 1.0',
'Pykka >= 1.1', 'Pykka >= 1.1',
'pygame' 'pygame'
], ],

BIN
setuptools-5.4.2.zip
View File

Binary file not shown.

2
tests/test_extension.py
View File

@@ -27,5 +27,3 @@ class ExtensionTest(unittest.TestCase):
# TODO Test the content of your config schema # TODO Test the content of your config schema
# self.assertIn('username', schema) # self.assertIn('username', schema)
# self.assertIn('password', schema) # self.assertIn('password', schema)
# TODO Write more tests