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

Search funtionality first preview (Bad icon)

Browse Source 
Some buttons shown only on main screen
This commit is contained in:
Ander
2014-11-20 13:02:18 +01:00
parent d8839a5559
commit 0e6e0c1006
7 changed files with 298 additions and 203 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
mopidy_touchscreen/library_screen.py
View File

@@ -12,8 +12,8 @@ class LibraryScreen():
self.size = size self.size = size
self.base_size = base_size self.base_size = base_size
self.manager = manager self.manager = manager
self.list_view = ListView((0, self.base_size), ( self.list_view = ListView((0, 0), (
self.size[0], self.size[1] - 2 * self.base_size), self.size[0], self.size[1] - self.base_size),
self.base_size, self.base_size,
manager.fonts['base']) manager.fonts['base'])
self.directory_list = [] self.directory_list = []

221
mopidy_touchscreen/main_screen.py
View File

@@ -3,6 +3,7 @@ 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
@@ -35,8 +36,58 @@ class MainScreen():
self.track_playback_ended(None, None) self.track_playback_ended(None, None)
else: else:
self.track_started(current_track) self.track_started(current_track)
# Top bar
self.top_bar = pygame.Surface((self.size[0], self.base_size),
pygame.SRCALPHA)
self.top_bar.fill((0, 0, 0, 128))
# Play/pause
button = TouchAndTextItem(self.fonts['icon'], u"\ue615 ",
(0, 0), None)
self.touch_text_manager.set_touch_object("pause_play", button)
x = button.get_right_pos()
# Random
button = TouchAndTextItem(self.fonts['icon'], u"\ue629 ",
(x, 0), None)
self.touch_text_manager.set_touch_object("random", button)
x = button.get_right_pos()
# Repeat
button = TouchAndTextItem(self.fonts['icon'], u"\ue626",
(x, 0), None)
self.touch_text_manager.set_touch_object("repeat", button)
x = button.get_right_pos()
# Single
button = TouchAndTextItem(self.fonts['base'], " 1 ", (x, 0),
None)
self.touch_text_manager.set_touch_object("single", button)
x = button.get_right_pos()
# Internet
button = TouchAndTextItem(self.fonts['icon'], u"\ue602 ",
(x, 0), None)
self.touch_text_manager.set_touch_object("internet", button)
x = button.get_right_pos()
# Mute
button = TouchAndTextItem(self.fonts['icon'], u"\ue61f ",
(x, 0), None)
self.touch_text_manager.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.touch_text_manager.set_touch_object("volume", progress)
progress.set_value(self.core.playback.volume.get())
def update(self, screen, update_all): def update(self, screen, update_all):
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(
"time_progress").set_value( "time_progress").set_value(
@@ -45,8 +96,9 @@ class MainScreen():
"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)
screen.blit(self.image, ( if self.image is not None:
self.base_size / 2, self.base_size + self.base_size / 2)) screen.blit(self.image, (
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
@@ -64,24 +116,24 @@ class MainScreen():
self.artists.append(artist) self.artists.append(artist)
# Track name # Track name
label = TextItem(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, self.size[1])) (width, -1))
self.touch_text_manager.set_object("track_name", label) self.touch_text_manager.set_touch_object("track_name", label)
# Album name # Album name
label = TextItem(self.fonts['base'], label = TouchAndTextItem(self.fonts['base'],
MainScreen.get_track_album_name(track), MainScreen.get_track_album_name(track),
(x, self.base_size * 3), (x, self.base_size * 3),
(width, self.size[1])) (width, -1))
self.touch_text_manager.set_object("album_name", label) self.touch_text_manager.set_touch_object("album_name", label)
# Artist # Artist
label = TextItem(self.fonts['base'], self.get_artist_string(), label = TouchAndTextItem(self.fonts['base'], self.get_artist_string(),
(x, self.base_size * 4), (x, self.base_size * 4),
(width, self.size[1])) (width, -1))
self.touch_text_manager.set_object("artist_name", label) self.touch_text_manager.set_touch_object("artist_name", label)
# Previous track button # Previous track button
button = TouchAndTextItem(self.fonts['icon'], u"\ue61c", button = TouchAndTextItem(self.fonts['icon'], u"\ue61c",
@@ -117,7 +169,6 @@ class MainScreen():
else: else:
self.load_image() self.load_image()
def get_artist_string(self): def get_artist_string(self):
artists_string = '' artists_string = ''
for artist in self.artists: for artist in self.artists:
@@ -173,27 +224,27 @@ class MainScreen():
# 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 = TextItem(self.fonts['base'], current = TouchAndTextItem(self.fonts['base'],
MainScreen.get_track_name(self.track), MainScreen.get_track_name(self.track),
(self.base_size / 2, (self.base_size / 2,
self.base_size * 2), self.base_size * 2),
(width, -1)) (width, -1))
self.touch_text_manager.set_object("track_name", current) self.touch_text_manager.set_touch_object("track_name", current)
current = TextItem(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_object("album_name", current) self.touch_text_manager.set_touch_object("album_name", current)
current = TextItem(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_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: if self.image is not None:
@@ -205,24 +256,22 @@ class MainScreen():
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 width = self.size[0] - self.base_size
current = TextItem(self.fonts['base'], "Stopped", current = TouchAndTextItem(self.fonts['base'], "",
(self.base_size / 2, self.base_size * 2), (self.base_size / 2, self.base_size * 2),
(width, -1)) (width, -1))
self.touch_text_manager.set_object("track_name", current) self.touch_text_manager.set_touch_object("track_name", current)
current = TextItem(self.fonts['base'], "", current = TouchAndTextItem(self.fonts['base'], "",
(self.base_size / 2, self.base_size * 3), (self.base_size / 2, self.base_size * 3),
(width, -1)) (width, -1))
self.touch_text_manager.set_object("album_name", current) self.touch_text_manager.set_touch_object("album_name", current)
current = TextItem(self.fonts['base'], "", current = TouchAndTextItem(self.fonts['base'], "",
(self.base_size / 2, self.base_size * 4), (self.base_size / 2, self.base_size * 4),
(width, -1)) (width, -1))
self.touch_text_manager.set_object("artist_name", current) 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
@@ -231,24 +280,14 @@ class MainScreen():
self.get_cover_folder() + self.get_cover_folder() +
self.get_image_file_name()).convert(), self.get_image_file_name()).convert(),
(size, size)) (size, size))
self.image_now_loaded = True
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 = self.touch_text_manager.get_touch_objects_in_pos(
event.current_pos) event.current_pos)
if objects is not None: if objects is not None:
for key in objects: self.click_on_objects(objects, event)
if key == "time_progress":
value = self.touch_text_manager.get_touch_object(
key).get_pos_value(
event.current_pos) * 1000
self.core.playback.seek(value)
elif key == "previous":
self.core.playback.previous()
elif key == "next":
self.core.playback.next()
elif event.type == InputManager.swipe: elif event.type == InputManager.swipe:
if event.direction == InputManager.left: if event.direction == InputManager.left:
self.core.playback.next() self.core.playback.next()
@@ -268,6 +307,114 @@ class MainScreen():
self.manager.backend.tell( self.manager.backend.tell(
{'action': 'volume', 'value': volume}) {'action': 'volume', 'value': volume})
self.manager.volume_changed(volume) self.manager.volume_changed(volume)
def click_on_objects(self, objects, event):
if objects is not None:
for key in objects:
if key == "time_progress":
value = self.touch_text_manager.get_touch_object(
key).get_pos_value(
event.current_pos) * 1000
self.core.playback.seek(value)
elif key == "previous":
self.core.playback.previous()
elif key == "next":
self.core.playback.next()
elif key == "volume":
self.change_volume(event)
elif key == "pause_play":
if self.core.playback.state.get() == \
mopidy.core.PlaybackState.PLAYING:
self.core.playback.pause()
else:
self.core.playback.play()
elif key == "mute":
mute = not self.core.playback.mute.get()
self.core.playback.set_mute(mute)
self.mute_changed(mute)
elif key == "random":
random = not self.core.tracklist.random.get()
self.core.tracklist.set_random(random)
self.options_changed()
elif key == "repeat":
self.core.tracklist.set_repeat(
not self.core.tracklist.repeat.get())
elif key == "single":
self.core.tracklist.set_single(
not self.core.tracklist.single.get())
elif key == "internet":
self.manager.check_connection()
elif key == "track_name":
self.manager.search(self.track.name, 0)
elif key == "album_name":
self.manager.search(self.track.album.name, 1)
elif key == "artist_name":
self.manager.search(self.get_artist_string(), 2)
def change_volume(self, event):
manager = self.touch_text_manager
volume = manager.get_touch_object("volume")
pos = event.current_pos
value = volume.get_pos_value(pos)
self.core.playback.volume = value
self.volume_changed(value)
def volume_changed(self, volume):
if not self.core.playback.mute.get():
if volume > 80:
self.touch_text_manager.get_touch_object(
"mute").set_text(
u"\ue61f", False)
elif volume > 50:
self.touch_text_manager.get_touch_object(
"mute").set_text(
u"\ue620", False)
elif volume > 20:
self.touch_text_manager.get_touch_object(
"mute").set_text(
u"\ue621", False)
else:
self.touch_text_manager.get_touch_object(
"mute").set_text(
u"\ue622", False)
self.touch_text_manager.get_touch_object("volume").set_value(
volume)
def options_changed(self):
self.touch_text_manager.get_touch_object("random").set_active(
self.core.tracklist.random.get())
self.touch_text_manager.get_touch_object("repeat").set_active(
self.core.tracklist.repeat.get())
self.touch_text_manager.get_touch_object("single").set_active(
self.core.tracklist.single.get())
def mute_changed(self, mute):
self.touch_text_manager.get_touch_object("mute").set_active(
not mute)
if mute:
self.touch_text_manager.get_touch_object("mute").set_text(
u"\ue623", False)
else:
self.volume_changed(self.core.playback.volume.get())
def playback_state_changed(self, old_state, new_state):
if new_state == mopidy.core.PlaybackState.PLAYING:
self.touch_text_manager.get_touch_object(
"pause_play").set_text(u"\ue616", False)
else:
self.touch_text_manager.get_touch_object(
"pause_play").set_text(u"\ue615", False)
def set_connection(self, connection, loading):
internet = self.touch_text_manager.get_touch_object("internet")
if loading:
internet.set_text(u"\ue627", None)
internet.set_active(False)
else:
internet.set_text(u"\ue602", None)
internet.set_active(connection)
@staticmethod @staticmethod
def get_track_name(track): def get_track_name(track):

14
mopidy_touchscreen/menu_screen.py
View File

@@ -17,42 +17,42 @@ class MenuScreen():
# Exit mopidy button # Exit mopidy button
button = TouchAndTextItem(self.manager.fonts['icon'], button = TouchAndTextItem(self.manager.fonts['icon'],
u"\ue611", u"\ue611",
(0, self.base_size), None) (0, 0), None)
self.screen_objects.set_touch_object("exit_icon", button) self.screen_objects.set_touch_object("exit_icon", button)
button = TouchAndTextItem(self.manager.fonts['base'], button = TouchAndTextItem(self.manager.fonts['base'],
"Exit Mopidy", "Exit Mopidy",
(button.get_right_pos(), (button.get_right_pos(),
self.base_size), 0),
None) None)
self.screen_objects.set_touch_object("exit", button) self.screen_objects.set_touch_object("exit", button)
# Shutdown button # Shutdown button
button = TouchAndTextItem(self.manager.fonts['icon'], button = TouchAndTextItem(self.manager.fonts['icon'],
u"\ue60b", u"\ue60b",
(0, self.base_size * 2), None) (0, self.base_size * 1), None)
self.screen_objects.set_touch_object("shutdown_icon", button) self.screen_objects.set_touch_object("shutdown_icon", button)
button = TouchAndTextItem(self.manager.fonts['base'], button = TouchAndTextItem(self.manager.fonts['base'],
"Shutdown", "Shutdown",
(button.get_right_pos(), (button.get_right_pos(),
self.base_size * 2), self.base_size * 1),
None) None)
self.screen_objects.set_touch_object("shutdown", button) self.screen_objects.set_touch_object("shutdown", button)
# Restart button # Restart button
button = TouchAndTextItem(self.manager.fonts['icon'], button = TouchAndTextItem(self.manager.fonts['icon'],
u"\ue609", u"\ue609",
(0, self.base_size * 3), None) (0, self.base_size * 2), None)
self.screen_objects.set_touch_object("restart_icon", button) self.screen_objects.set_touch_object("restart_icon", button)
button = TouchAndTextItem(self.manager.fonts['base'], button = TouchAndTextItem(self.manager.fonts['base'],
"Restart", "Restart",
(button.get_right_pos(), (button.get_right_pos(),
self.base_size * 3), self.base_size * 2),
None) None)
self.screen_objects.set_touch_object("restart", button) self.screen_objects.set_touch_object("restart", button)
# IP addres # IP addres
button = TouchAndTextItem(self.manager.fonts['base'], "IP: ", button = TouchAndTextItem(self.manager.fonts['base'], "IP: ",
(0, self.base_size * 4), None) (0, self.base_size * 3), None)
self.screen_objects.set_touch_object("ip", button) self.screen_objects.set_touch_object("ip", button)
def update(self, screen, update_all): def update(self, screen, update_all):

4
mopidy_touchscreen/playlist_screen.py
View File

@@ -6,8 +6,8 @@ class PlaylistScreen():
self.size = size self.size = size
self.base_size = base_size self.base_size = base_size
self.manager = manager self.manager = manager
self.list_view = ListView((0, self.base_size), ( self.list_view = ListView((0, 0), (
self.size[0], self.size[1] - 2 * self.base_size), self.size[0], self.size[1] - self.base_size),
self.base_size, self.base_size,
manager.fonts['base']) manager.fonts['base'])
self.playlists_strings = [] self.playlists_strings = []

199
mopidy_touchscreen/screen_manager.py
View File

@@ -5,6 +5,7 @@ import mopidy.core
import pygame import pygame
from pkg_resources import Requirement, resource_filename from pkg_resources import Requirement, resource_filename
from .search_screen import SearchScreen
from .library_screen import LibraryScreen from .library_screen import LibraryScreen
from .main_screen import MainScreen from .main_screen import MainScreen
from .menu_screen import MenuScreen from .menu_screen import MenuScreen
@@ -17,6 +18,13 @@ from .tracklist import Tracklist
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
search_index = 0
main_screen_index = 1
tracklist_index = 2
library_index = 3
playlist_index = 4
menu_index = 5
class ScreenManager(): class ScreenManager():
def __init__(self, size, core, cache): def __init__(self, size, core, cache):
@@ -33,6 +41,7 @@ class ScreenManager():
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),
MainScreen(size, self, cache, core, self.fonts), MainScreen(size, self, cache, core, self.fonts),
Tracklist(size, self.base_size, self), Tracklist(size, self.base_size, self),
LibraryScreen(size, self.base_size, self), LibraryScreen(size, self.base_size, self),
@@ -48,90 +57,49 @@ class ScreenManager():
self.dirty_area = [] self.dirty_area = []
self.screen_changed = True self.screen_changed = True
# Top bar
self.top_bar = pygame.Surface((self.size[0], self.base_size),
pygame.SRCALPHA)
self.top_bar.fill((0, 0, 0, 128))
# Play/pause
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)
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)
self.top_bar_objects.set_touch_object("repeat", button)
x = button.get_right_pos()
# Single
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)
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)
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.top_bar_objects.set_touch_object("volume", progress)
progress.set_value(self.core.playback.volume.get())
# Menu buttons # Menu buttons
button_size = (self.size[0] / 5, self.base_size) button_size = (self.size[0] / 6, self.base_size)
# Main button # Search button
button = TouchAndTextItem(self.fonts['icon'], u" \ue600", button = TouchAndTextItem(self.fonts['icon'], u" \ue601",
(0, self.base_size * 7), (0, self.base_size * 7),
button_size) button_size)
self.down_bar_objects.set_touch_object("menu_0", button) self.down_bar_objects.set_touch_object("menu_0", button)
x = button.get_right_pos() x = button.get_right_pos()
# Main button
button = TouchAndTextItem(self.fonts['icon'], u" \ue600",
(x, self.base_size * 7),
button_size)
self.down_bar_objects.set_touch_object("menu_1", button)
x = button.get_right_pos()
# Tracklist button # Tracklist button
button = TouchAndTextItem(self.fonts['icon'], u" \ue60d", button = TouchAndTextItem(self.fonts['icon'], u" \ue60d",
(x, self.base_size * 7), (x, self.base_size * 7),
button_size) button_size)
self.down_bar_objects.set_touch_object("menu_1", button) self.down_bar_objects.set_touch_object("menu_2", button)
x = button.get_right_pos() x = button.get_right_pos()
# Library button # Library button
button = TouchAndTextItem(self.fonts['icon'], u" \ue604", button = TouchAndTextItem(self.fonts['icon'], u" \ue604",
(x, self.base_size * 7), (x, self.base_size * 7),
button_size) button_size)
self.down_bar_objects.set_touch_object("menu_2", button) self.down_bar_objects.set_touch_object("menu_3", button)
x = button.get_right_pos() x = button.get_right_pos()
# Playlist button # Playlist button
button = TouchAndTextItem(self.fonts['icon'], u" \ue605", button = TouchAndTextItem(self.fonts['icon'], u" \ue605",
(x, self.base_size * 7), (x, self.base_size * 7),
button_size) button_size)
self.down_bar_objects.set_touch_object("menu_3", button) self.down_bar_objects.set_touch_object("menu_4", button)
x = button.get_right_pos() x = button.get_right_pos()
# Menu button # Menu button
button = TouchAndTextItem(self.fonts['icon'], u" \ue60a", button = TouchAndTextItem(self.fonts['icon'], u" \ue60a",
(x, self.base_size * 7), None) (x, self.base_size * 7), None)
self.down_bar_objects.set_touch_object("menu_4", 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(
@@ -143,17 +111,15 @@ class ScreenManager():
self.mute_changed(self.core.playback.mute.get()) self.mute_changed(self.core.playback.mute.get())
self.playback_state_changed(self.core.playback.state.get(), self.playback_state_changed(self.core.playback.state.get(),
self.core.playback.state.get()) self.core.playback.state.get())
self.screens[4].check_connection() self.screens[menu_index].check_connection()
self.change_screen(self.current_screen) self.change_screen(self.current_screen)
self.top_bar_objects.set_selected("pause_play")
def update(self): def update(self):
surface = pygame.Surface(self.size) surface = pygame.Surface(self.size)
surface.fill([200, 200, 200]) surface.fill([200, 200, 200])
self.screens[self.current_screen].update(surface, self.screens[self.current_screen].update(surface,
self.screen_changed) self.screen_changed)
surface.blit(self.top_bar, (0, 0))
surface.blit(self.down_bar, (0, self.base_size * 7)) surface.blit(self.down_bar, (0, self.base_size * 7))
self.top_bar_objects.render(surface) self.top_bar_objects.render(surface)
self.down_bar_objects.render(surface) self.down_bar_objects.render(surface)
@@ -162,20 +128,11 @@ class ScreenManager():
def track_started(self, track): def track_started(self, track):
self.track = track self.track = track
self.screens[0].track_started(track.track) self.screens[main_screen_index].track_started(track.track)
self.screens[1].track_started(track) self.screens[tracklist_index].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.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
def track_playback_ended(self, tl_track, time_position): def track_playback_ended(self, tl_track, time_position):
self.screens[0].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)
@@ -200,91 +157,21 @@ class ScreenManager():
self.screens[self.current_screen].touch_event(event) self.screens[self.current_screen].touch_event(event)
def volume_changed(self, volume): def volume_changed(self, volume):
if not self.core.playback.mute.get(): self.screens[main_screen_index].volume_changed(volume)
if volume > 80:
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(
u"\ue620", False)
elif volume > 20:
self.top_bar_objects.get_touch_object(
"mute").set_text(
u"\ue621", False)
else:
self.top_bar_objects.get_touch_object(
"mute").set_text(
u"\ue622", False)
self.top_bar_objects.get_touch_object("volume").set_value(
volume)
def click_on_objects(self, objects, event):
if objects is not None:
for key in objects:
if key == "volume":
self.change_volume(event)
elif key == "pause_play":
if self.core.playback.state.get() == \
mopidy.core.PlaybackState.PLAYING:
self.core.playback.pause()
else:
self.core.playback.play()
elif key == "mute":
mute = not self.core.playback.mute.get()
self.core.playback.set_mute(mute)
self.mute_changed(mute)
elif key == "random":
random = not self.core.tracklist.random.get()
self.core.tracklist.set_random(random)
self.options_changed()
elif key == "repeat":
self.core.tracklist.set_repeat(
not self.core.tracklist.repeat.get())
elif key == "single":
self.core.tracklist.set_single(
not self.core.tracklist.single.get())
elif key == "internet":
self.screens[4].check_connection()
elif key[:-1] == "menu_":
self.change_screen(int(key[-1:]))
def change_volume(self, event):
manager = self.top_bar_objects
volume = manager.get_touch_object("volume")
pos = event.current_pos
value = volume.get_pos_value(pos)
self.core.playback.volume = value
self.volume_changed(value)
def playback_state_changed(self, old_state, new_state): def playback_state_changed(self, old_state, new_state):
if new_state == mopidy.core.PlaybackState.PLAYING: self.screens[main_screen_index].playback_state_changed(old_state, new_state)
self.top_bar_objects.get_touch_object(
"pause_play").set_text(u"\ue616", False)
else:
self.top_bar_objects.get_touch_object(
"pause_play").set_text(u"\ue615", False)
def mute_changed(self, mute): def mute_changed(self, mute):
self.top_bar_objects.get_touch_object("mute").set_active( self.screens[main_screen_index].mute_changed(mute)
not mute)
if mute:
self.top_bar_objects.get_touch_object("mute").set_text(
u"\ue623", False)
else:
self.volume_changed(self.core.playback.volume.get())
def tracklist_changed(self): def tracklist_changed(self):
self.screens[1].tracklist_changed() self.screens[tracklist_index].tracklist_changed()
def options_changed(self): def options_changed(self):
self.top_bar_objects.get_touch_object("random").set_active( self.screens[main_screen_index].options_changed()
self.core.tracklist.random.get())
self.top_bar_objects.get_touch_object("repeat").set_active(
self.core.tracklist.repeat.get())
self.top_bar_objects.get_touch_object("single").set_active(
self.core.tracklist.single.get())
def change_screen(self, new_screen): def change_screen(self, new_screen):
self.screen_changed = True self.screen_changed = True
@@ -296,17 +183,23 @@ class ScreenManager():
self.dirty_area.append( self.dirty_area.append(
pygame.Rect(0, 0, self.size[0], self.size[1])) pygame.Rect(0, 0, self.size[0], self.size[1]))
def click_on_objects(self, objects, event):
if objects is not None:
for key in objects:
if key[:-1] == "menu_":
self.change_screen(int(key[-1:]))
def playlists_loaded(self): def playlists_loaded(self):
self.screens[3].playlists_loaded() self.screens[playlist_index].playlists_loaded()
def set_connection(self, connection, loading): def set_connection(self, connection, loading):
internet = self.top_bar_objects.get_touch_object("internet") self.screens[main_screen_index].set_connection(connection, loading)
if loading:
internet.set_text(u"\ue627", None) def check_connection(self):
internet.set_active(False) self.screens[menu_index].check_connection()
else:
internet.set_text(u"\ue602", None) def search(self, query, mode):
internet.set_active(connection) self.screens[search_index].search(query, mode)
def change_selection(self, event, pos): def change_selection(self, event, pos):
if self.selected_zone == self.top_bar_objects: if self.selected_zone == self.top_bar_objects:

55
mopidy_touchscreen/search_screen.py Normal file
View File

@@ -0,0 +1,55 @@
from .list_view import ListView
import logging
logger = logging.getLogger(__name__)
mode_track_name = 0
mode_album_name = 1
mode_artist_name = 2
class SearchScreen():
def __init__(self, size, base_size, manager):
self.size = size
self.base_size = base_size
self.manager = manager
self.list_view = ListView((0, 0), (
self.size[0], self.size[1] - self.base_size),
self.base_size,
manager.fonts['base'])
self.results_strings = []
self.results = []
def update(self, screen, update_all):
self.list_view.render(screen)
def search(self, query, mode):
if mode == mode_track_name:
search_query = {'any': [query]}
elif mode == mode_album_name:
search_query = {'album': [query]}
else:
search_query = {'artist': [query]}
current_results = self.manager.core.library.search(search_query).get()
self.results = []
self.results_strings = []
for backend in current_results:
if mode == mode_track_name:
iterable = backend.tracks
elif mode == mode_album_name:
iterable = backend.albums
else:
iterable = backend.artists
for result in iterable:
self.results.append(result)
self.results_strings.append(result.name)
self.list_view.set_list(self.results_strings)
def touch_event(self, touch_event):
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.results[clicked].uri)
self.manager.core.playback.play()

4
mopidy_touchscreen/tracklist.py
View File

@@ -7,8 +7,8 @@ class Tracklist():
self.size = size self.size = size
self.base_size = base_size self.base_size = base_size
self.manager = manager self.manager = manager
self.list_view = ListView((0, self.base_size), ( self.list_view = ListView((0, 0), (
self.size[0], self.size[1] - 2 * self.base_size), self.size[0], self.size[1] - self.base_size),
self.base_size, self.base_size,
manager.fonts['base']) manager.fonts['base'])
self.tracks = [] self.tracks = []