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

Animation

Browse Source
This commit is contained in:
9and3r
2015-07-14 01:41:58 +02:00
parent 9828f10c31
commit 194d6fa071
11 changed files with 324 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
mopidy_touchscreen/graphic_utils/list_view.py
View File

@@ -80,15 +80,19 @@ class ListView():
else:
return False
def render(self, surface, update_all, rects):
def set_update_rects(self, rects):
for key in self.update_keys:
object = self.screen_objects.get_touch_object(key)
object.update()
rects.append(object.rect_in_pos)
def render(self, surface, update_all):
if update_all:
self.screen_objects.render(surface)
else:
for key in self.update_keys:
object = self.screen_objects.get_touch_object(key)
object.update()
object.render(surface)
rects.append(object.rect_in_pos)
def touch_event(self, touch_event):
self.must_update = True

59
mopidy_touchscreen/graphic_utils/screen_objects.py
View File

@@ -21,6 +21,22 @@ class ScreenObjectsManager:
def set_object(self, key, add_object):
self.text_objects[key] = add_object
def get_update_rects(self):
update_rects = []
for key in self.text_objects:
object = self.text_objects[key]
if hasattr(object, "fit_horizontal") and not object.fit_horizontal:
update_rects.append(object.rect_in_pos)
for key in self.touch_objects:
object = self.touch_objects[key]
if hasattr(object, "fit_horizontal") and not object.fit_horizontal:
update_rects.append(object.rect_in_pos)
return update_rects
def set_horizontal_shift(self, shift):
for key in self.text_objects:
self.text_objects[key].set_horizontal_shift(shift)
def get_object(self, key):
return self.text_objects[key]
@@ -72,10 +88,11 @@ class ScreenObjectsManager:
self.selected_key = None
class BaseItem():
def __init__(self, pos, size):
class BaseItem:
def __init__(self, pos, size, horizontal_shift=0):
self.pos = pos
self.size = size
self.horizontal_shift = horizontal_shift
self.rect = pygame.Rect(0, 0, self.size[0], self.size[1])
self.rect_in_pos = pygame.Rect(self.pos[0], self.pos[1],
self.size[0],
@@ -84,16 +101,31 @@ class BaseItem():
def get_right_pos(self):
return self.pos[0] + self.size[0]
def set_horizontal_shift(self, shift):
self.horizontal_shift = shift
def update(self):
return False
class ImageView(BaseItem):
def __init__(self, pos, size, horizontal_shift=0):
BaseItem.__init__(self, pos, size, horizontal_shift)
self.image = None
def set_image(self, image):
self.image = image
def render(self, surface):
if self.image is not None:
surface.blit(self.image, (self.pos[0] + self.horizontal_shift, self.pos[1]))
class TextItem(BaseItem):
scroll_speed = 2
def __init__(self, font, text, pos, size, center=False, background=None,
scroll_no_fit=True):
scroll_no_fit=True, horizontal_shift=0):
self.font = font
self.text = text
self.scroll_no_fit = scroll_no_fit
@@ -104,11 +136,11 @@ class TextItem(BaseItem):
if size is not None:
if size[1] == -1:
height = self.font.size(text)[1]
BaseItem.__init__(self, pos, (size[0], height))
BaseItem.__init__(self, pos, (size[0], height), horizontal_shift)
else:
BaseItem.__init__(self, pos, size)
BaseItem.__init__(self, pos, size, horizontal_shift)
else:
BaseItem.__init__(self, pos, self.font.size(text))
BaseItem.__init__(self, pos, self.font.size(text), horizontal_shift)
if size is not None:
if self.pos[0] + self.box.get_rect().width > pos[0] + \
size[0]:
@@ -155,25 +187,26 @@ class TextItem(BaseItem):
if self.background:
surface.fill(self.background, rect=self.rect_in_pos)
pygame.draw.rect(surface, (0, 0, 0), self.rect_in_pos, 1)
pos = (self.pos[0] + self.horizontal_shift, self.pos[1])
if self.fit_horizontal:
surface.blit(
self.box, ((self.pos[0] + self.margin),
self.box, ((pos[0] + self.margin),
self.pos[1]), area=self.rect)
else:
if self.scroll_no_fit:
surface.blit(self.box, self.pos,
surface.blit(self.box, pos,
area=pygame.Rect(self.step, 0, self.size[0],
self.size[1]))
if self.step_2 is not None:
surface.blit(self.box, (self.pos[0]+self.step_2,
self.pos[1]),
surface.blit(self.box, (pos[0]+self.step_2,
pos[1]),
area=pygame.Rect(0, 0,
self.size[0] -
self.step_2,
self.size[1]))
else:
step = self.box.get_rect().width - self.size[0]
surface.blit(self.box, self.pos,
surface.blit(self.box, pos,
area=pygame.Rect(step, 0, self.size[0],
self.size[1]))
@@ -182,11 +215,11 @@ class TextItem(BaseItem):
if change_size:
TextItem.__init__(self, self.font, text, self.pos,
None, self.center, self.background,
self.scroll_no_fit)
self.scroll_no_fit, self.horizontal_shift)
else:
TextItem.__init__(self, self.font, text, self.pos,
self.size, self.center, self.background,
self.scroll_no_fit)
self.scroll_no_fit, self.horizontal_shift)
def add_text(self, add_text, change_size):
self.set_text(self.text+add_text, change_size)

84
mopidy_touchscreen/graphic_utils/view_pager.py Normal file
View File

@@ -0,0 +1,84 @@
__author__ = 'ander'
from ..screens.base_screen import BaseScreen
import traceback
class ViewPager:
def __init__(self, size, manager):
self.size = size
self.objets_manager = [manager.create_objects_manager(), manager.create_objects_manager(), manager.create_objects_manager()]
self.pos = 0
self.manager = manager
self.next = False
self.direction = 0
self.previous = False
self.speed = self.size[0] / 15
self.update = False
self.update_rects = []
def notify_changed(self):
try:
for i in range(0, 3, 1):
self.manager.set_page_values(self.objets_manager[i], i)
self.update = True
except:
traceback.print_exc()
def change_to_page(self, page):
self.direction = page
self.update = True
def should_update(self):
if self.update:
return BaseScreen.update_all
else:
if len(self.update_rects)>0:
return BaseScreen.update_partial
else:
return BaseScreen.no_update
def shift(self):
if self.direction == 1:
if -self.pos > self.size[0]:
self.pos = 0
self.direction = 0
aux = self.objets_manager[0]
self.objets_manager[0] = self.objets_manager[1]
self.objets_manager[1] = self.objets_manager[2]
self.objets_manager[2] = aux
self.notify_changed()
else:
self.pos -= self.speed
self.objets_manager[2].set_horizontal_shift(self.size[0] + self.pos)
self.objets_manager[1].set_horizontal_shift(self.pos)
elif self.direction == -1:
if self.pos > self.size[0]:
self.pos = 0
self.direction = 0
aux = self.objets_manager[2]
self.objets_manager[2] = self.objets_manager[1]
self.objets_manager[1] = self.objets_manager[0]
self.objets_manager[0] = aux
self.notify_changed()
else:
self.pos += self.speed
self.objets_manager[0].set_horizontal_shift(-self.size[0] + self.pos)
self.objets_manager[1].set_horizontal_shift(self.pos)
def render(self, screen, update_type):
if self.direction != 0:
self.shift()
if self.pos != 0:
if self.direction == 1:
self.objets_manager[2].render(screen)
elif self.direction == -1:
self.objets_manager[0].render(screen)
else:
self.update = False
self.update_rects = self.objets_manager[1].get_update_rects()
#if update_type == BaseScreen.update_partial:
#rects += self.update_rects
self.objets_manager[1].render(screen)

19
mopidy_touchscreen/screen_manager.py
View File

@@ -147,23 +147,26 @@ class ScreenManager():
if self.background.should_update():
return BaseScreen.update_all
else:
if self.screens[self.current_screen].should_update():
return BaseScreen.update_partial
else:
return BaseScreen.no_update
return self.screens[self.current_screen].should_update()
def update(self, screen):
update_type = self.get_update_type()
if update_type != BaseScreen.no_update:
rects = []
surface = self.background.draw_background()
if self.keyboard:
surface = self.background.draw_background()
self.keyboard.update(surface)
else:
if update_type == BaseScreen.update_partial:
self.screens[self.current_screen].set_update_rects(rects)
surface = self.background.draw_background()
else:
surface = self.background.draw_background()
self.screens[self.current_screen].\
update(surface, update_type, rects)
surface.blit(self.down_bar, (0, self.size[1] - self.base_size))
self.down_bar_objects.render(surface)
update(surface, update_type)
if update_type == BaseScreen.update_all:
surface.blit(self.down_bar, (0, self.size[1] - self.base_size))
self.down_bar_objects.render(surface)
if update_type == BaseScreen.update_all or len(rects) < 1:
screen.blit(surface, (0, 0))

5
mopidy_touchscreen/screens/base_screen.py
View File

@@ -10,7 +10,7 @@ class BaseScreen():
self.manager = manager
self.fonts = fonts
def update(self, surface, update_type, rects):
def update(self, surface, update_type):
"""
Draw this screen to the surface
@@ -26,5 +26,8 @@ class BaseScreen():
def change_screen(self, direction):
return False
def set_update_rects(self, rects):
pass
def should_update(self):
return BaseScreen.update_partial

12
mopidy_touchscreen/screens/library_screen.py
View File

@@ -38,11 +38,17 @@ class LibraryScreen(BaseScreen):
self.browse_uri(directory)
def should_update(self):
return self.list_view.should_update()
if self.list_view.should_update():
return BaseScreen.update_partial
else:
return BaseScreen.no_update
def update(self, screen, update_type, rects):
def set_update_rects(self, rects):
self.list_view.set_update_rects(rects)
def update(self, screen, update_type):
update_all = (update_type == BaseScreen.update_all)
self.list_view.render(screen, update_all, rects)
self.list_view.render(screen, update_all)
def touch_event(self, touch_event):
clicked = self.list_view.touch_event(touch_event)

259
mopidy_touchscreen/screens/main_screen.py
View File

@@ -14,8 +14,9 @@ import mopidy.core
import pygame
from ..graphic_utils import Progressbar, \
from ..graphic_utils import ImageView, Progressbar, \
ScreenObjectsManager, TextItem, TouchAndTextItem
from ..graphic_utils.view_pager import ViewPager
from ..input import InputManager
@@ -28,6 +29,8 @@ class MainScreen(BaseScreen):
BaseScreen.__init__(self, size, base_size, manager, fonts)
self.core = core
self.track = None
self.previous_track = None
self.next_track = None
self.cache = cache
self.image = None
self.artists = None
@@ -36,6 +39,7 @@ class MainScreen(BaseScreen):
self.update_keys = []
self.current_track_pos = 0
self.track_duration = "00:00"
self.view_pager = ViewPager(self.size, self)
self.touch_text_manager = ScreenObjectsManager()
current_track = self.core.playback.current_track.get()
if current_track is None:
@@ -66,46 +70,48 @@ class MainScreen(BaseScreen):
100, True)
self.touch_text_manager.set_touch_object("volume", progress)
progress.set_value(self.core.playback.volume.get())
self.progress_show = False
def should_update(self):
if len(self.update_keys) > 0:
return True
def should_update(self, rects):
update = self.view_pager.should_update()
if update is not BaseScreen.no_update:
return update
elif len(self.update_keys) > 0:
return BaseScreen.update_partial
else:
if self.progress_show:
track_pos_millis = self.core.playback.time_position.get()
new_track_pos = track_pos_millis / 1000
if new_track_pos != self.current_track_pos:
return True
return BaseScreen.update_partial
else:
return False
return BaseScreen.no_update
else:
return False
return BaseScreen.no_update
def update(self, screen, update_type, rects):
def set_update_rects(self, rects):
progress = self.update_progress()
if progress is not None:
self.update_keys.append("time_progress")
rects.append(progress.rect_in_pos)
def update(self, screen, update_type):
if update_type == BaseScreen.update_all:
screen.blit(self.top_bar, (0, 0))
self.update_progress(screen, rects)
self.update_progress()
self.touch_text_manager.render(screen)
if self.image is not None:
screen.blit(self.image, (
self.base_size / 2, self.base_size +
self.base_size / 2))
self.view_pager.render(screen, update_type)
if update_type == BaseScreen.update_partial \
and self.track is not None:
progress = self.update_progress(screen, rects)
if progress is not None:
progress.render(screen)
rects.append(progress.rect_in_pos)
for key in self.update_keys:
object = self.touch_text_manager.get_object(key)
object.update()
object.render(screen)
rects.append(object.rect_in_pos)
self.view_pager.render(screen, update_type)
def update_progress(self, screen, rects):
def update_progress(self):
if self.progress_show:
track_pos_millis = self.core.playback.time_position.get()
new_track_pos = track_pos_millis / 1000
@@ -122,12 +128,80 @@ class MainScreen(BaseScreen):
return progress
return None
def track_started(self, track):
self.update_keys = []
self.image = None
def create_objects_manager(self):
touch_text_manager = ScreenObjectsManager()
x = self.size[1] - self.base_size * 3
width = self.size[0] - self.base_size / 2 - x
# Track name
label = TextItem(self.fonts['base'],
"",
(x, (self.size[1]-self.base_size*3)/2
- self.base_size*0.5),
(width, -1))
touch_text_manager.set_object("track_name", label)
# Album name
label = TextItem(self.fonts['base'],
"",
(x, (self.size[1]-self.base_size*3)/2
+ self.base_size*0.5),
(width, -1))
touch_text_manager.set_object("album_name", label)
# Artist
label = TextItem(self.fonts['base'],
"",
(x, (self.size[1]-self.base_size*3)/2
+ self.base_size*1.5),
(width, -1))
touch_text_manager.set_object("artist_name", label)
# Cover image
pos = (self.base_size / 2, self.base_size +
self.base_size / 2)
size = self.size[1] - self.base_size * 4
cover = ImageView(pos, (size, size))
touch_text_manager.set_object("cover_image", cover)
return touch_text_manager
def set_page_values(self, screen_objects_manager, pos):
if pos == 0:
track = self.previous_track
elif pos == 1:
track = self.track
elif pos == 2:
track = self.next_track
if track is None:
return False
else:
screen_objects_manager.get_object("track_name").set_horizontal_shift(200)
screen_objects_manager.get_object("track_name").set_text(MainScreen.get_track_name(track), False)
screen_objects_manager.get_object("album_name").set_text(MainScreen.get_track_album_name(track), False)
screen_objects_manager.get_object("artist_name").set_text(MainScreen.get_artist_string(track), False)
return True
def track_started(self, track):
self.next_track = track
self.update_keys = []
self.image = None
self.view_pager.notify_changed()
if self.previous_track is not None and track.uri == self.previous_track.uri:
logger.error("sartu naiz")
self.view_pager.change_to_page(-1)
image_view = self.view_pager.objets_manager[0].get_object("cover_image")
else:
self.view_pager.change_to_page(1)
image_view = self.view_pager.objets_manager[2].get_object("cover_image")
image_view.set_image(None)
self.previous_track = self.track
self.track = track
# Previous track button
button = TouchAndTextItem(self.fonts['icon'], u"\ue61c",
(0, self.size[1] - self.base_size * 2), None)
@@ -167,61 +241,19 @@ class MainScreen(BaseScreen):
for artist in track.artists:
self.artists.append(artist)
# Track name
label = TextItem(self.fonts['base'],
MainScreen.get_track_name(track),
(x, (self.size[1]-self.base_size*3)/2
- self.base_size*0.5),
(width, -1))
if not label.fit_horizontal:
self.update_keys.append("track_name")
self.touch_text_manager.set_object("track_name", label)
# Album name
label = TextItem(self.fonts['base'],
MainScreen.get_track_album_name
(track),
(x, (self.size[1]-self.base_size*3)/2
+ self.base_size*0.5),
(width, -1))
if not label.fit_horizontal:
self.update_keys.append("album_name")
self.touch_text_manager.set_object("album_name", label)
# Artist
label = TextItem(self.fonts['base'],
self.get_artist_string(),
(x, (self.size[1]-self.base_size*3)/2
+ self.base_size*1.5),
(width, -1))
if not label.fit_horizontal:
self.update_keys.append("artist_name")
self.touch_text_manager.set_object("artist_name", label)
self.track = track
if not self.is_image_in_cache():
thread = Thread(target=self.download_image)
thread = Thread(target=self.download_image, args=[image_view])
thread.start()
else:
thread = Thread(target=self.load_image)
thread = Thread(target=self.load_image, args=[image_view])
thread.start()
def stream_title_changed(self, title):
self.touch_text_manager.get_object("track_name").set_text(title, False)
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()
self.track) + '-' + self.get_artist_string(self.track)
md5name = hashlib.md5(name.encode('utf-8')).hexdigest()
return md5name
@@ -235,18 +267,19 @@ class MainScreen(BaseScreen):
return os.path.isfile(
self.get_cover_folder() + self.get_image_file_name())
def download_image(self):
def download_image(self, image_view):
image_uris = self.core.library.get_images(
{self.track.uri}).get()[self.track.uri]
if len(image_uris) > 0:
urllib.urlretrieve(image_uris[0].uri,
self.get_cover_folder() +
self.get_image_file_name())
self.load_image()
self.load_image(image_view)
else:
self.download_image_last_fm(0)
self.download_image_last_fm(0, image_view)
def download_image_last_fm(self, artist_index):
def download_image_last_fm(self, artist_index, image_view):
if artist_index < len(self.artists):
try:
safe_artist = urllib.quote_plus(
@@ -265,81 +298,26 @@ class MainScreen(BaseScreen):
urllib.urlretrieve(image,
self.get_cover_folder() +
self.get_image_file_name())
self.load_image()
self.load_image(image_view)
except:
self.download_image_last_fm(artist_index + 1)
self.download_image_last_fm(artist_index + 1, image_view)
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 = TextItem(self.fonts['base'],
MainScreen.get_track_name
(self.track),
(self.base_size / 2,
self.base_size * 2),
(width, -1))
if not current.fit_horizontal:
self.update_keys.append("track_name")
self.touch_text_manager.set_object("track_name", current)
current = TextItem(self.fonts['base'],
MainScreen.get_track_album_name
(self.track),
(self.base_size / 2,
self.base_size * 3),
(width, -1))
if not current.fit_horizontal:
self.update_keys.append("album_name")
self.touch_text_manager.set_object("album_name", current)
current = TextItem(self.fonts['base'],
self.get_artist_string(),
(self.base_size / 2,
self.base_size * 4),
(width, -1))
if not current.fit_horizontal:
self.update_keys.append("artist_name")
self.touch_text_manager.set_object("artist_name", current)
self.background.set_background_image(None)
def track_playback_ended(self, tl_track, time_position):
self.background.set_background_image(None)
self.image = None
self.track_duration = "00:00"
width = self.size[0] - self.base_size
current = TextItem(self.fonts['base'], "",
(self.base_size / 2,
self.base_size * 2),
(width, -1))
self.touch_text_manager.set_object("track_name", current)
current = TextItem(self.fonts['base'], "",
(self.base_size / 2,
self.base_size * 3),
(width, -1))
self.touch_text_manager.set_object("album_name", current)
current = TextItem(self.fonts['base'], "",
(self.base_size / 2,
self.base_size * 4),
(width, -1))
self.touch_text_manager.set_object("artist_name", current)
def load_image(self):
def load_image(self, image_view):
size = self.size[1] - self.base_size * 4
image_original = pygame.image.load(
self.get_cover_folder() +
self.get_image_file_name())
image = pygame.transform.scale(image_original, (size, size))
image = image.convert()
self.image = image
image_view.set_image(image)
self.background.set_background_image(image_original)
def touch_event(self, event):
@@ -459,15 +437,32 @@ class MainScreen(BaseScreen):
@staticmethod
def get_track_name(track):
if track.name is None:
if track is None:
return ""
elif track.name is None:
return track.uri
else:
return track.name
@staticmethod
def get_track_album_name(track):
if track is None:
return ""
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"
@staticmethod
def get_artist_string(track):
artists_string = ''
if track is None:
return artists_string
for artist in track.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

12
mopidy_touchscreen/screens/menu_screen.py
View File

@@ -20,11 +20,17 @@ class MenuScreen(BaseScreen):
self.list.set_list(self.list_items)
def should_update(self):
return self.list.should_update()
if self.list.should_update():
return BaseScreen.update_partial
else:
return BaseScreen.no_update
def update(self, screen, update_type, rects):
def set_update_rects(self, rects):
self.list_view.set_update_rects(rects)
def update(self, screen, update_type):
update_all = (update_type == BaseScreen.update_all)
self.list.render(screen, update_all, rects)
self.list.render(screen, update_all)
def touch_event(self, event):
clicked = self.list.touch_event(event)

12
mopidy_touchscreen/screens/playlist_screen.py
View File

@@ -18,11 +18,17 @@ class PlaylistScreen(BaseScreen):
self.playlists_loaded()
def should_update(self):
return self.list_view.should_update()
if self.list_view.should_update():
return BaseScreen.update_partial
else:
return BaseScreen.no_update
def update(self, screen, update_type, rects):
def set_update_rects(self, rects):
self.list_view.set_update_rects(rects)
def update(self, screen, update_type):
update_all = (update_type == BaseScreen.update_all)
self.list_view.render(screen, update_all, rects)
self.list.render(screen, update_all)
def playlists_loaded(self):
self.selected_playlist = None

12
mopidy_touchscreen/screens/search_screen.py
View File

@@ -74,13 +74,19 @@ class SearchScreen(BaseScreen):
self.set_query("Search")
def should_update(self):
return self.list_view.should_update()
if self.list_view.should_update():
return BaseScreen.update_partial
else:
return BaseScreen.no_update
def update(self, screen, update_type, rects):
def set_update_rects(self, rects):
self.list_view.set_update_rects(rects)
def update(self, screen, update_type):
screen.blit(self.top_bar, (0, 0))
self.screen_objects.render(screen)
update_all = (update_type == BaseScreen.update_all)
self.list_view.render(screen, update_all, rects)
self.list_view.render(screen, update_all)
def set_mode(self, mode=mode_track_name):
if mode is not self.mode:

12
mopidy_touchscreen/screens/tracklist.py
View File

@@ -20,11 +20,17 @@ class Tracklist(BaseScreen):
self.manager.core.playback.current_tl_track.get())
def should_update(self):
return self.list_view.should_update()
if self.list_view.should_update():
return BaseScreen.update_partial
else:
return BaseScreen.no_update
def update(self, screen, update_type, rects):
def set_update_rects(self, rects):
self.list_view.set_update_rects(rects)
def update(self, screen, update_type):
update_all = (update_type == BaseScreen.update_all)
self.list_view.render(screen, update_all, rects)
self.list_view.render(screen, update_all)
def tracklist_changed(self):
self.update_list()