def __play_new_tracks(self, uris):
"""
Play new tracks
@param uri as [str]
"""
# First get tracks
tracks = []
for uri in uris:
track_id = App().tracks.get_id_by_uri(uri)
tracks.append(Track(track_id))
# Then get album ids
album_ids = {}
for track in tracks:
if track.album.id in album_ids.keys():
album_ids[track.album.id].append(track)
else:
album_ids[track.album.id] = [track]
# Create albums with tracks
play = True
for album_id in album_ids.keys():
album = Album(album_id)
album.set_tracks(album_ids[album_id])
if play:
App().player.play_album(album)
else:
App().player.add_album(album)
def __on_disc_button_press_event(self, button, event, disc):
"""
Add disc to playback
@param button as Gtk.Button
@param event as Gdk.ButtonEvent
@param disc as Disc
"""
album = Album(disc.album.id)
album.set_tracks(disc.tracks)
App().player.play_album(album)
def __get(self, search_items, cancellable):
"""
Get track for name
@param search_items as [str]
@param cancellable as Gio.Cancellable
@return items as [(int, Album, bool)]
"""
album_ids = self.__search_albums(search_items, cancellable)
track_ids = self.__search_tracks(search_items, cancellable)
artist_ids = self.__search_artists(search_items, cancellable)
# Get tracks/albums for artists
for artist_id in set(artist_ids):
if cancellable.is_cancelled():
return []
for album_id in App().albums.get_ids([artist_id], []):
if album_id not in album_ids:
album_ids.append(album_id)
for track_id in App().tracks.get_ids_by_artist(artist_id):
if track_id not in track_ids:
track_ids.append(track_id)
albums = []
# Create albums for tracks
album_tracks = {}
for track_id in track_ids:
track = Track(track_id)
if track.album.id in album_ids:
continue
score = self.__calculate_score(track.name, search_items)
for artist in track.artists:
score += self.__calculate_score(artist, search_items)
# Get a new album
album = track.album
if album.id in album_tracks.keys():
(album, tracks, score) = album_tracks[album.id]
tracks.append(track)
album_tracks[track.album.id] = (album, tracks, score)
else:
album_tracks[track.album.id] = (album, [track], score)
# Create albums for album results
for album_id in album_ids:
album = Album(album_id)
score = self.__calculate_score(album.name, search_items)
for artist in album.artists:
score += self.__calculate_score(artist, search_items)
albums.append((score, album, False))
# Merge albums from track results
for key in album_tracks.keys():
(album, tracks, score) = album_tracks[key]
album.set_tracks(tracks)
albums.append((score, album, True))
albums.sort(key=lambda tup: tup[0], reverse=True)
return albums
def __on_play_button_clicked(self, button):
"""
Play disc
@param button as Gtk.Button
"""
try:
App().player.clear_albums()
album = Album(self.__object.album.id)
# search wanted disc
for disc in album.discs:
if disc.number == self.__object.number:
album.set_tracks(disc.tracks)
break
App().player.add_album(album)
App().player.load(album.tracks[0])
except Exception as e:
Logger.error("ContextWidget::__on_play_button_clicked(): %s", e)
def __on_insert_album(self, row, new_album_id, track_ids, down):
"""
Insert a new row at position
@param row as AlbumRow
@param new_track_id as int
@param track_ids as [int]
@param down as bool
"""
position = self._box.get_children().index(row)
if down:
position += 1
album = Album(new_album_id)
album.set_tracks([Track(track_id) for track_id in track_ids])
new_row = self.__row_for_album(album)
new_row.populate()
new_row.show()
self._box.insert(new_row, position)
App().player.add_album(album, position)
def __on_insert_album(self, row, new_album_id, track_ids, down):
"""
Insert a new row at position
@param row as Row
@param new_album_id as int
@param track_ids as int
@param down as bool
"""
# Backup album as __destroy_split() will unset it
album = row.track.album
new_album = Album(new_album_id)
tracks = [Track(track_id) for track_id in track_ids]
new_album.set_tracks(tracks)
split_album = Album(row.track.album.id)
split_tracks = self.__get_split_tracks(row, down)
split_album.set_tracks(split_tracks)
self.emit("insert-album-after", album, new_album)
self.emit("insert-album-after", new_album, split_album)
self.__destroy_split(row, down)
def update_artwork(self, width, height):
"""
Update artwork
@param width as int
@param height as int
"""
same_artwork = self._previous_artwork_id ==\
App().player.current_track.album.id and not self.__per_track_cover
if width < 1 or height < 1 or same_artwork:
return
self._previous_artwork_id = App().player.current_track.album.id
scale_factor = self._artwork.get_scale_factor()
if App().player.current_track.id == Type.RADIOS:
App().art_helper.set_radio_artwork(
App().player.current_track.radio_name,
width,
height,
scale_factor,
self.__effect,
self._on_artwork,
)
elif App().player.current_track.id is not None:
if self.__per_track_cover:
effect = self.__effect | ArtBehaviour.NO_CACHE
album = Album(App().player.current_track.album.id)
App().art.clean_album_cache(album, width * scale_factor,
height * scale_factor)
album.set_tracks([App().player.current_track])
else:
effect = self.__effect
album = App().player.current_track.album
App().art_helper.set_album_artwork(
album,
width,
height,
scale_factor,
effect,
self._on_artwork,
)
if self.__show_tooltip:
self._artwork.set_tooltip_text(
App().player.current_track.album.name)
def __on_insert_track(self, row, new_track_id, down):
"""
Insert a new row at position
@param row as PlaylistRow
@param new_track_id as int
@param down as bool
"""
new_track = Track(new_track_id)
children = self._box.get_children()
position = children.index(row)
lenght = len(children)
if down:
position += 1
# Append track to current/next album
if position < lenght and\
children[position].album.id == new_track.album.id:
new_track.set_album(children[position].album)
children[position].prepend_rows([new_track])
children[position].album.insert_track(new_track, 0)
# Append track to previous/current album
elif position - 1 < lenght and\
children[position - 1].album.id == new_track.album.id:
new_track.set_album(children[position - 1].album)
children[position - 1].append_rows([new_track])
children[position - 1].album.insert_track(new_track)
# Add a new album
else:
album = Album(new_track.album.id)
album.set_tracks([new_track])
new_row = self.__row_for_album(album)
new_row.populate()
new_row.show()
self._box.insert(new_row, position)
App().player.add_album(album, position)
if row.previous_row is not None and\
row.previous_row.album.id ==\
App().player.current_track.album.id:
App().player.set_next()
App().player.set_prev()
def __on_insert_track(self, row, new_track_id, down):
"""
Insert a new row at position
@param row as PlaylistRow
@param new_track_id as int
@param down as bool
"""
track = Track(new_track_id)
# If same album, add track to album
if track.album.id == row.track.album.id:
position = self.children.index(row)
new_row = TrackRow(track, track.album.artist_ids, self._view_type)
new_row.connect("destroy", self.__on_row_destroy)
new_row.connect("insert-track", self.__on_insert_track)
new_row.connect("insert-album", self.__on_insert_album)
new_row.connect("remove-track", self.__on_remove_track)
new_row.connect("do-selection", self.__on_do_selection)
new_row.show()
if down:
position += 1
new_row.set_previous_row(row)
new_row.set_next_row(row.next_row)
if row.next_row is not None:
row.next_row.set_previous_row(new_row)
row.set_next_row(new_row)
else:
new_row.set_previous_row(row.previous_row)
new_row.set_next_row(row)
if row.previous_row is not None:
row.previous_row.set_next_row(new_row)
row.set_previous_row(new_row)
new_row.update_number(position + 1)
row.get_parent().insert(new_row, position)
row.track.album.insert_track(track, position)
if new_row.previous_row is not None and\
new_row.previous_row.track.id ==\
App().player.current_track.id:
App().player.set_next()
App().player.set_prev()
# Else, we need to insert a new album with the track
else:
# Backup album as __destroy_split() will unset it
album = row.track.album
split_album = Album(album.id)
split_tracks = self.__get_split_tracks(row, down)
# Create new album
track.album.set_tracks([track])
# We use DNDRow because we know that if tracks are DND
# we are DND. Little hack
if len(self.children) == len(split_tracks):
if self.previous_row is not None:
album = self.previous_row.album
else:
album = Album()
elif not split_tracks:
if self.next_row is not None:
album = self.next_row.album
else:
album = Album()
if album.id == track.album.id:
track.set_album(album)
if down:
self.next_row.prepend_rows([track])
else:
self.previous_row.append_rows([track])
else:
self.emit("insert-album-after",
album,
track.album)
# Create split album
if split_tracks:
split_album.set_tracks(split_tracks)
if album.id == track.album.id:
self.emit("insert-album-after", album, split_album)
else:
self.emit("insert-album-after", track.album, split_album)
self.__destroy_split(row, down)
def __get(self, search_items, cancellable):
"""
Get track for name
@param search_items as str
@param cancellable as Gio.Cancellable
@return items as [(int, Album, bool)]
"""
split_items = self.__split_string(search_items)
album_ids = self.__search_albums(split_items, cancellable)
track_ids = self.__search_tracks(split_items, cancellable)
artist_ids = self.__search_artists(split_items, cancellable)
albums = []
all_album_ids = []
album_tracks = {}
# Get performers tracks
for artist_id in artist_ids:
for track_id in App().tracks.get_ids_by_performer(artist_id):
if track_id not in track_ids:
track_ids.append(track_id)
# Merge albums for tracks
for track_id in track_ids:
if cancellable.is_cancelled():
return []
track = Track(track_id)
# Get a new album
album = track.album
if album.id in album_tracks.keys():
(album, tracks) = album_tracks[album.id]
tracks.append(track)
album_tracks[track.album.id] = (album, tracks)
else:
album_tracks[track.album.id] = (album, [track])
# Create albums for album results
for album_id in album_ids:
if cancellable.is_cancelled():
return []
if album_id not in all_album_ids:
all_album_ids.append(album_id)
album = Album(album_id)
score = self.__calculate_score(album, search_items)
albums.append((score, album, False))
# Get tracks/albums for artists
for artist_id in artist_ids:
if cancellable.is_cancelled():
return []
for album_id in App().albums.get_ids([artist_id], []):
if album_id not in all_album_ids:
album = Album(album_id)
score = self.__calculate_score(album, search_items)
albums.append((score, album, False))
# Create albums from track results
for key in album_tracks.keys():
if cancellable.is_cancelled():
return []
(album, tracks) = album_tracks[key]
if album.id not in all_album_ids:
album.set_tracks(tracks)
score = self.__calculate_score(album, search_items)
for track in album.tracks:
score += self.__calculate_score(track, search_items)
all_album_ids.append(album.id)
albums.append((score, album, True))
albums.sort(key=lambda tup: tup[0], reverse=True)
return [(album, in_tracks) for (score, album, in_tracks) in albums]