Febbweiss/mopidy-touchscreen
1
0
Fork 0
mirror of https://github.com/Febbweiss/mopidy-touchscreen.git synced 2026-03-05 06:35:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Code cleanup

Browse Source 
Create packages
This commit is contained in:
Ander
2015-01-22 02:12:49 +01:00
parent b9e0a0c6cc
commit cbd553cebd
17 changed files with 34 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

13
mopidy_touchscreen/screens/base_screen.py Normal file
View File

@@ -0,0 +1,13 @@
class BaseScreen():
def __init__(self, size, base_size, manager, fonts):
self.size = size
self.base_size = base_size
self.manager = manager
self.fonts = fonts
def update(self, surface):
pass
def event(self, event):
pass

70
mopidy_touchscreen/screens/library_screen.py Normal file
View File

@@ -0,0 +1,70 @@
import mopidy.models
from base_screen import BaseScreen
from ..graphic_utils import *
class LibraryScreen(BaseScreen):
def __init__(self, size, base_size, manager, fonts):
BaseScreen.__init__(self, size, base_size, manager, fonts)
self.list_view = ListView((0, 0), (
self.size[0], self.size[1] -
self.base_size), self.base_size, self.fonts['base'])
self.directory_list = []
self.current_directory = None
self.library = None
self.library_strings = None
self.browse_uri(None)
def go_inside_directory(self, uri):
self.directory_list.append(self.current_directory)
self.current_directory = uri
self.browse_uri(uri)
def browse_uri(self, uri):
self.library_strings = []
if uri is not None:
self.library_strings.append("../")
self.library = self.manager.core.library.browse(uri).get()
for lib in self.library:
self.library_strings.append(lib.name)
self.list_view.set_list(self.library_strings)
def go_up_directory(self):
if len(self.directory_list):
directory = self.directory_list.pop()
self.current_directory = directory
self.browse_uri(directory)
def update(self, screen):
self.list_view.render(screen)
def touch_event(self, touch_event):
clicked = self.list_view.touch_event(touch_event)
if clicked is not None:
if self.current_directory is not None:
if clicked == 0:
self.go_up_directory()
else:
if self.library[clicked - 1].type\
== mopidy.models.Ref.TRACK:
self.play_uri(clicked-1)
else:
self.go_inside_directory(
self.library[clicked - 1].uri)
else:
self.go_inside_directory(self.library[clicked].uri)
def play_uri(self, track_pos):
self.manager.core.tracklist.clear()
tracks = []
for item in self.library:
if item.type == mopidy.models.Ref.TRACK:
tracks.append(self.manager.core.library.lookup(
item.uri).get()[0])
else:
track_pos -= 1
self.manager.core.tracklist.add(tracks)
self.manager.core.playback.play(
tl_track=self.manager.core.tracklist.tl_tracks.get()
[track_pos])

435
mopidy_touchscreen/screens/main_screen.py Normal file
View File

@@ -0,0 +1,435 @@
import hashlib
import json
import logging
import os
import time
import urllib
import urllib2
from threading import Thread
import mopidy.core
from base_screen import BaseScreen
from ..input import InputManager
from ..graphic_utils import *
logger = logging.getLogger(__name__)
class MainScreen(BaseScreen):
def __init__(self, size, base_size, manager, fonts, cache, core,
background):
BaseScreen.__init__(self, size, base_size, manager, fonts)
self.core = core
self.track = None
self.cache = cache
self.image = None
self.artists = None
self.background = background
self.track_duration = "00:00"
self.touch_text_manager = ScreenObjectsManager()
current_track = self.core.playback.current_track.get()
if current_track is None:
self.track_playback_ended(None, None)
else:
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):
screen.blit(self.top_bar, (0, 0))
if self.track is not None:
self.touch_text_manager.get_touch_object(
"time_progress").set_value(
self.core.playback.time_position.get() / 1000)
self.touch_text_manager.get_touch_object(
"time_progress").set_text(
time.strftime('%M:%S', time.gmtime(
self.core.playback.time_position.get() / 1000)) +
"/" + self.track_duration)
if self.image is not None:
screen.blit(self.image, (
self.base_size / 2, self.base_size +
self.base_size / 2))
self.touch_text_manager.render(screen)
return screen
def track_started(self, track):
self.image = None
x = self.base_size * 5
width = self.size[0] - self.base_size / 2 - x
self.track_duration = time.strftime('%M:%S', time.gmtime(
track.length / 1000))
# Load all artists
self.artists = []
for artist in track.artists:
self.artists.append(artist)
# Track name
label = TouchAndTextItem(self.fonts['base'],
MainScreen.get_track_name(track),
(x, self.base_size * 2), (width, -1))
self.touch_text_manager.set_touch_object("track_name", label)
# Album name
label = TouchAndTextItem(self.fonts['base'],
MainScreen.get_track_album_name
(track), (x, self.base_size * 3),
(width, -1))
self.touch_text_manager.set_touch_object("album_name", label)
# Artist
label = TouchAndTextItem(self.fonts['base'],
self.get_artist_string(),
(x, self.base_size * 4),
(width, -1))
self.touch_text_manager.set_touch_object("artist_name", label)
# Previous track button
button = TouchAndTextItem(self.fonts['icon'], u"\ue61c",
(0, self.base_size * 6), None)
self.touch_text_manager.set_touch_object("previous", button)
size_1 = button.get_right_pos()
size_2 = self.fonts['icon'].size(u"\ue61d")[0]
button = TouchAndTextItem(self.fonts['icon'], u"\ue61d",
(self.size[0] - size_2,
self.base_size * 6),
None)
self.touch_text_manager.set_touch_object("next", button)
# Progress
progress = Progressbar(self.fonts['base'],
time.strftime('%M:%S', time.gmtime(
0)) + "/" + time.strftime(
'%M:%S', time.gmtime(0)),
(size_1, self.base_size * 6),
(
self.size[0] - size_1 - size_2,
self.base_size),
track.length / 1000, False)
self.touch_text_manager.set_touch_object("time_progress",
progress)
self.track = track
if not self.is_image_in_cache():
thread = Thread(target=self.download_image(0))
thread.start()
else:
self.load_image()
def get_artist_string(self):
artists_string = ''
for artist in self.artists:
artists_string += artist.name + ', '
if len(artists_string) > 2:
artists_string = artists_string[:-2]
elif len(artists_string) == 0:
artists_string = "Unknow Artist"
return artists_string
def get_image_file_name(self):
name = MainScreen.get_track_album_name(
self.track) + '-' + self.get_artist_string()
md5name = hashlib.md5(name.encode('utf-8')).hexdigest()
return md5name
def get_cover_folder(self):
if not os.path.isdir(self.cache + "/covers"):
os.makedirs(self.cache + "/covers")
return self.cache + "/covers/"
def is_image_in_cache(self):
self.get_cover_folder()
return os.path.isfile(
self.get_cover_folder() + self.get_image_file_name())
def download_image(self, artist_index):
if artist_index < len(self.artists):
try:
safe_artist = urllib.quote_plus(
self.artists[artist_index].name)
safe_album = urllib.quote_plus(
MainScreen.get_track_album_name(self.track))
url = "http://ws.audioscrobbler.com/2.0/?"
params = "method=album.getinfo&" + \
"api_key=59a04c6a73fb99d6e8996e01db306829&" \
+ "artist=" \
+ safe_artist + "&album=" + safe_album + \
"&format=json"
response = urllib2.urlopen(url + params)
data = json.load(response)
image = data['album']['image'][-1]['#text']
urllib.urlretrieve(image,
self.get_cover_folder() +
self.get_image_file_name())
self.load_image()
except:
self.download_image(artist_index + 1)
else:
logger.info("Cover could not be downloaded")
# There is no cover
# so it will use all the screen size for the text
width = self.size[0] - self.base_size
current = TouchAndTextItem(self.fonts['base'],
MainScreen.get_track_name
(self.track),
(self.base_size / 2,
self.base_size * 2),
(width, -1))
self.touch_text_manager.set_touch_object("track_name",
current)
current = TouchAndTextItem(self.fonts['base'],
MainScreen.get_track_album_name
(self.track),
(self.base_size / 2,
self.base_size * 3),
(width, -1))
self.touch_text_manager.set_touch_object("album_name",
current)
current = TouchAndTextItem(self.fonts['base'],
self.get_artist_string(),
(self.base_size / 2,
self.base_size * 4),
(width, -1))
self.touch_text_manager.set_touch_object("artist_name",
current)
def track_playback_ended(self, tl_track, time_position):
self.background.set_target_color(None)
self.image = None
self.track_duration = "00:00"
width = self.size[0] - self.base_size
current = TouchAndTextItem(self.fonts['base'], "",
(self.base_size / 2,
self.base_size * 2),
(width, -1))
self.touch_text_manager.set_touch_object("track_name",
current)
current = TouchAndTextItem(self.fonts['base'], "",
(self.base_size / 2,
self.base_size * 3),
(width, -1))
self.touch_text_manager.set_touch_object("album_name",
current)
current = TouchAndTextItem(self.fonts['base'], "",
(self.base_size / 2,
self.base_size * 4),
(width, -1))
self.touch_text_manager.set_touch_object("artist_name",
current)
def load_image(self):
size = self.base_size * 4
image = pygame.transform.scale(pygame.image.load(
self.get_cover_folder() +
self.get_image_file_name()).convert(), (size, size))
self.background.set_target_color(
pygame.transform.average_color(image))
self.image = image
def touch_event(self, event):
if event.type == InputManager.click:
objects = \
self.touch_text_manager.get_touch_objects_in_pos(
event.current_pos)
if objects is not None:
self.click_on_objects(objects, event)
elif event.type == InputManager.swipe:
if event.direction == InputManager.left:
self.core.playback.next()
elif event.direction == InputManager.right:
self.core.playback.previous()
elif event.direction == InputManager.up:
volume = self.core.playback.volume.get() + 10
if volume > 100:
volume = 100
self.core.playback.volume = volume
self.manager.volume_changed(volume)
elif event.direction == InputManager.down:
volume = self.core.playback.volume.get() - 10
if volume < 0:
volume = 0
self.core.playback.volume = 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
def get_track_name(track):
if track.name is None:
return track.uri
else:
return track.name
@staticmethod
def get_track_album_name(track):
if track.album is not None and track.album.name is not None\
and len(track.album.name) > 0:
return track.album.name
else:
return "Unknow Album"

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

@@ -0,0 +1,92 @@
import os
import socket
import mopidy
from base_screen import BaseScreen
from ..input import InputManager
from ..graphic_utils import *
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):
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("sudo shutdown now -h")
elif key == "restart_icon" or key == "restart":
if os.system("gksu -- shutdown -r now") != 0:
os.system("sudo 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)

55
mopidy_touchscreen/screens/playlist_screen.py Normal file
View File

@@ -0,0 +1,55 @@
from base_screen import BaseScreen
from ..graphic_utils import *
class PlaylistScreen(BaseScreen):
def __init__(self, size, base_size, manager, fonts):
BaseScreen.__init__(self, size, base_size, manager, fonts)
self.list_view = ListView((0, 0), (
self.size[0], self.size[1] -
self.base_size), self.base_size,
self.fonts['base'])
self.playlists_strings = []
self.playlists = []
self.playlists_loaded()
self.selected_playlist = None
self.playlist_tracks = []
self.playlist_tracks_strings = []
def update(self, screen):
self.list_view.render(screen)
def playlists_loaded(self):
self.selected_playlist = None
self.playlists_strings = []
self.playlists = []
for playlist in self.manager.core.playlists.playlists.get():
self.playlists.append(playlist)
self.playlists_strings.append(playlist.name)
self.list_view.set_list(self.playlists_strings)
def playlist_selected(self, playlist):
self.selected_playlist = playlist
self.playlist_tracks = playlist.tracks
self.playlist_tracks_strings = ["../"]
for track in self.playlist_tracks:
self.playlist_tracks_strings.append(track.name)
self.list_view.set_list(self.playlist_tracks_strings)
def touch_event(self, touch_event):
clicked = self.list_view.touch_event(touch_event)
if clicked is not None:
if self.selected_playlist is None:
self.playlist_selected(self.playlists[clicked])
else:
if clicked == 0:
self.selected_playlist = None
self.list_view.set_list(self.playlists_strings)
else:
self.manager.core.tracklist.clear()
self.manager.core.tracklist.add(
self.playlist_tracks)
self.manager.core.playback.play(
tl_track=self.manager.core.
tracklist.tl_tracks.get()
[clicked-1])

132
mopidy_touchscreen/screens/search_screen.py Normal file
View File

@@ -0,0 +1,132 @@
import pygame
from base_screen import BaseScreen
from ..input import InputManager
from ..graphic_utils import *
mode_track_name = 0
mode_album_name = 1
mode_artist_name = 2
class SearchScreen(BaseScreen):
def __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.size[0], self.size[1] -
3*self.base_size), self.base_size, manager.fonts['base'])
self.results_strings = []
self.results = []
self.screen_objects = ScreenObjectsManager()
self.query = ""
# Query text
text = TextItem(self.fonts['base'], self.query, (0, 0),
(self.size[0], self.base_size), center=True)
self.screen_objects.set_object("query", text)
# Mode buttons
button_size = (self.size[0] / 3, self.base_size)
self.mode_objects_keys = ["mode_track", "mode_album",
"mode_artist"]
# Track button
button = TouchAndTextItem(self.fonts['base'], "Track",
(0, self.base_size),
button_size, center=True)
self.screen_objects.set_touch_object(
self.mode_objects_keys[0], button)
# Album button
button = TouchAndTextItem(self.fonts['base'], "Album",
(button_size[0], self.base_size),
button_size, center=True)
self.screen_objects.set_touch_object(
self.mode_objects_keys[1], button)
# Artist button
button = TouchAndTextItem(self.fonts['base'], "Artist",
(button_size[0]*2, self.base_size),
button_size, center=True)
self.screen_objects.set_touch_object(
self.mode_objects_keys[2], button)
# Top Bar
self.top_bar = pygame.Surface(
(self.size[0], self.base_size * 2),
pygame.SRCALPHA)
self.top_bar.fill((0, 0, 0, 128))
self.mode = -100
self.set_mode(mode=mode_track_name)
self.set_query("")
def update(self, screen):
screen.blit(self.top_bar, (0, 0))
self.screen_objects.render(screen)
self.list_view.render(screen)
def set_mode(self, mode=mode_track_name):
if mode is not self.mode:
self.mode = mode
for key in self.mode_objects_keys:
self.screen_objects.get_touch_object(key).\
set_active(False)
self.screen_objects.get_touch_object(
self.mode_objects_keys[self.mode]).set_active(True)
def set_query(self, query=""):
self.query = query
self.screen_objects.get_object("query").set_text(
self.query, False)
def search(self, query=None, mode=None):
if query is not None:
self.set_query(query)
if mode is not None:
self.set_mode(mode)
if self.mode == mode_track_name:
search_query = {'any': [self.query]}
elif self.mode == mode_album_name:
search_query = {'album': [self.query]}
else:
search_query = {'artist': [self.query]}
if len(self.query) > 0:
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):
if touch_event.type == InputManager.click:
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()
else:
clicked = self.screen_objects.get_touch_objects_in_pos(
touch_event.down_pos)
if len(clicked) > 0:
clicked = clicked[0]
if clicked == self.mode_objects_keys[0]:
self.search(mode=0)
if clicked == self.mode_objects_keys[1]:
self.search(mode=1)
if clicked == self.mode_objects_keys[2]:
self.search(mode=2)
else:
self.list_view.touch_event(touch_event)

43
mopidy_touchscreen/screens/tracklist.py Normal file
View File

@@ -0,0 +1,43 @@
from base_screen import BaseScreen
from ..graphic_utils import *
from .main_screen import MainScreen
class Tracklist(BaseScreen):
def __init__(self, size, base_size, manager, fonts):
BaseScreen.__init__(self, size, base_size, manager, fonts)
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, self.fonts['base'])
self.tracks = []
self.tracks_strings = []
self.update_list()
self.track_started(
self.manager.core.playback.current_tl_track.get())
def update(self, screen):
self.list_view.render(screen)
def tracklist_changed(self):
self.update_list()
def update_list(self):
self.tracks = self.manager.core.tracklist.tl_tracks.get()
self.tracks_strings = []
for tl_track in self.tracks:
self.tracks_strings.append(
MainScreen.get_track_name(tl_track.track))
self.list_view.set_list(self.tracks_strings)
def touch_event(self, touch_event):
pos = self.list_view.touch_event(touch_event)
if pos is not None:
self.manager.core.playback.change_track(self.tracks[pos],
on_error_step=1)
def track_started(self, track):
self.list_view.set_active(
[self.manager.core.tracklist.index(track).get()])