def _insert_album_art(self, item, cb_item, itr, x=False):
if item and cb_item and not item.get_thumbnail():
if cb_item.get_thumbnail():
item.set_thumbnail(cb_item.get_thumbnail())
albumArtCache.get_default().lookup(item, self._iconWidth,
self._iconHeight,
self._on_lookup_ready, itr)
def _update_album_art(self, item, _iter):
albumArtCache.get_default().lookup(
item,
self._iconWidth,
self._iconHeight,
self._on_lookup_ready, _iter)
return False
def _insert_album_art(self, item, cb_item, itr, x=False):
if item and cb_item and not item.get_thumbnail():
if cb_item.get_thumbnail():
item.set_thumbnail(cb_item.get_thumbnail())
albumArtCache.get_default().lookup(
item,
self._iconWidth,
self._iconHeight,
self._on_lookup_ready, itr)
def _update_album_art(self, item, _iter):
albumArtCache.get_default().lookup_or_resolve(
item,
self._iconWidth,
self._iconHeight,
lambda icon, data: self._model.set_value(
_iter, 4,
albumArtCache.get_default()._make_icon_frame(icon)
if icon else None))
return False
def _add_item(self, source, param, item, remaining):
if not item:
return
self._offset += 1
item.set_title(albumArtCache.get_media_title(item))
artist = item.get_string(Grl.METADATA_KEY_ARTIST)\
or item.get_author()\
or _("Unknown Artist")
_iter = self._model.insert_with_valuesv(
-1,
[2, 3, 5, 8, 9, 10],
[albumArtCache.get_media_title(item),
artist, item, self.nowPlayingIconName, False, False])
self.player.discover_item(item, self._on_discovered, _iter)
def _add_item(self, source, param, item):
if item:
self._offset += 1
_iter = self._model.append()
artist = item.get_string(Grl.METADATA_KEY_ARTIST)
if not artist:
artist = item.get_author()
if not artist:
artist = _("Unknown Artist")
title = albumArtCache.get_media_title(item)
item.set_title(title)
try:
if item.get_url():
self.player.discoverer.discover_uri(item.get_url())
self._model.set(_iter,
[0, 1, 2, 3, 4, 5, 7, 8, 9, 10],
[str(item.get_id()), "", title,
artist, self._symbolicIcon, item,
-1, self.nowPlayingIconName, False, False])
except:
print("failed to discover url " + item.get_url())
self._model.set(_iter,
[0, 1, 2, 3, 4, 5, 7, 8, 9, 10],
[str(item.get_id()), "", title,
artist, self._symbolicIcon, item,
-1, self.errorIconName, False, True])
GLib.idle_add(self.show_album_art_data)
def update_model(self, player, playlist, currentIter):
# self is not our playlist, return
if (playlist != self.model):
return False
currentSong = playlist.get_value(currentIter, 5)
song_passed = False
_iter = playlist.get_iter_first()
self.duration = 0
while _iter:
song = playlist.get_value(_iter, 5)
self.duration += song.get_duration()
escapedTitle = AlbumArtCache.get_media_title(song, True)
if (song == currentSong):
title = '<b>%s</b>' % escapedTitle
iconVisible = True
song_passed = True
elif (song_passed):
title = '<span>%s</span>' % escapedTitle
iconVisible = False
else:
title = '<span color=\'grey\'>%s</span>' % escapedTitle
iconVisible = False
playlist.set_value(_iter, 0, title)
if (playlist.get_value(_iter, 7) != ERROR_ICON_NAME):
playlist.set_value(_iter, 9, iconVisible)
_iter = playlist.iter_next(_iter)
self.ui.get_object('running_length_label_info').set_text(
_("%d min") % (int(self.duration / 60) + 1))
return False
def load(self, media):
self._set_duration(media.get_duration())
self.songTotalTimeLabel.set_label(self.seconds_to_string(media.get_duration()))
self.progressScale.set_sensitive(True)
self.playBtn.set_sensitive(True)
self._sync_prev_next()
self.coverImg.set_from_pixbuf(self._symbolicIcon)
self.cache.lookup(ART_SIZE, media.get_artist(), media.get_string(Grl.METADATA_KEY_ALBUM), self._on_cache_lookup)
self.titleLabel.set_label(AlbumArtCache.get_media_title(media))
if media.get_artist() is not None:
self.artistLabel.set_label(media.get_artist())
else:
self.artistLabel.set_label("Unknown artist")
url = media.get_url()
if url != self.player.get_value("current-uri", 0):
self.player.set_property("uri", url)
#Store next available url
#(not really useful because we can't connect to about-to-finish, but still)
nextTrack = self._get_next_track()
if nextTrack:
nextMedia = self.playlist.get_value(self.currentTrack, self.playlistField)
self.player.nextUrl = nextMedia.get_url()
else:
self.player.nextUrl = None
self.emit("playlist-item-changed", self.playlist, self.currentTrack)
self.emit('current-changed')
def __init__(self):
GObject.GObject.__init__(self)
self.playlist = None
self.playlistType = None
self.playlistId = None
self.playlistField = None
self.currentTrack = None
self._lastState = Gst.State.PAUSED
self.cache = AlbumArtCache.get_default()
self._symbolicIcon = self.cache.make_default_icon(ART_SIZE, ART_SIZE)
Gst.init(None)
self.discoverer = GstPbutils.Discoverer()
self.discoverer.connect('discovered', self._on_discovered)
self.discoverer.start()
self._discovering_urls = {}
self.player = Gst.ElementFactory.make('playbin', 'player')
self.bus = self.player.get_bus()
self.bus.add_signal_watch()
self._settings = Gio.Settings.new('org.gnome.Music')
self._settings.connect('changed::repeat', self._on_settings_changed)
self.repeat = self._settings.get_enum('repeat')
self.bus.connect('message::state-changed', self._on_bus_state_changed)
self.bus.connect('message::error', self._onBusError)
self.bus.connect('message::eos', self._on_bus_eos)
self._setup_view()
self.playlist_insert_handler = 0
self.playlist_delete_handler = 0
def load(self, media):
self.progressScale.set_value(0)
self._set_duration(media.get_duration())
self.songTotalTimeLabel.set_label(
self.seconds_to_string(media.get_duration()))
self.progressScale.set_sensitive(True)
self.playBtn.set_sensitive(True)
self._sync_prev_next()
self.coverImg.set_from_pixbuf(self._symbolicIcon)
self.cache.lookup(media, ART_SIZE, ART_SIZE, self._on_cache_lookup)
self.titleLabel.set_label(AlbumArtCache.get_media_title(media))
if media.get_artist() is not None:
self.artistLabel.set_label(media.get_artist())
else:
self.artistLabel.set_label(_("Unknown Artist"))
url = media.get_url()
if url != self.player.get_value('current-uri', 0):
self.player.set_property('uri', url)
currentTrack = self.playlist.get_iter(self.currentTrack.get_path())
self.emit('playlist-item-changed', self.playlist, currentTrack)
self.emit('current-changed')
def __init__(self, player):
self._player = player
self._notification = Notify.Notification()
self._notification.set_category('x-gnome.music')
self._notification.set_hint('action-icons', GLib.Variant('b', True))
self._notification.set_hint('resident', GLib.Variant('b', True))
self._notification.set_hint('desktop-entry',
GLib.Variant('s', 'gnome-music'))
self._isPlaying = False
self._albumArtCache = AlbumArtCache.get_default()
self._noArtworkIcon = self._albumArtCache.get_default_icon(
IMAGE_SIZE, IMAGE_SIZE)
rowStride = self._noArtworkIcon.get_rowstride()
hasAlpha = self._noArtworkIcon.get_has_alpha()
bitsPerSample = self._noArtworkIcon.get_bits_per_sample()
nChannels = self._noArtworkIcon.get_n_channels()
data = self._noArtworkIcon.get_pixels()
self._noArtworkIconSerialized = GLib.Variant(
'(iiibiiay)', (IMAGE_SIZE, IMAGE_SIZE, rowStride, hasAlpha,
bitsPerSample, nChannels, data))
self._player.connect('playing-changed', self._on_playing_changed)
self._player.connect('current-changed', self._update_track)
self._player.connect('thumbnail-updated', self._on_thumbnail_updated)
def __init__(self, album, player, model):
super(Gtk.HBox, self).__init__()
self.player = player
self.album = album
self.artist = album.get_string(Grl.METADATA_KEY_ARTIST)
self.model = model
self.songs = []
self.ui = Gtk.Builder()
self.ui.add_from_resource('/org/gnome/Music/ArtistAlbumWidget.ui')
self.cache = AlbumArtCache.get_default()
pixbuf = self.cache.make_default_icon(128, 128)
GLib.idle_add(self._update_album_art)
self.ui.get_object("cover").set_from_pixbuf(pixbuf)
self.ui.get_object("title").set_label(album.get_title())
if album.get_creation_date():
self.ui.get_object("year").set_markup(
"<span color='grey'>(%s)</span>" %
str(album.get_creation_date().get_year())
)
self.tracks = []
GLib.idle_add(grilo.populate_album_songs,
album.get_id(), self.get_songs)
self.pack_start(self.ui.get_object("ArtistAlbumWidget"), True, True, 0)
self.show_all()
def _add_item(self, source, param, item):
if not item:
return
self._offset += 1
artist = item.get_string(Grl.METADATA_KEY_ARTIST)\
or item.get_author()\
or _("Unknown Artist")
title = albumArtCache.get_media_title(item)
item.set_title(title)
def add_new_item():
_iter = self._model.append(None)
icon_name = self.nowPlayingIconName
if item.get_url():
try:
self.player.discoverer.discover_uri(item.get_url())
except:
print('failed to discover url ' + item.get_url())
icon_name = self.errorIconName
self._model.set(_iter, [0, 1, 2, 3, 4, 5, 7, 8, 9, 10], [
str(item.get_id()), '', title, artist, self._symbolicIcon,
item, -1, icon_name, False, icon_name == self.errorIconName
])
GLib.idle_add(self._update_album_art, item, _iter)
GLib.idle_add(add_new_item)
def update_model(self, player, playlist, currentIter):
# this is not our playlist, return
if playlist != self.model:
# TODO, only clean once, but that can wait util we have clean
# the code a bit, and until the playlist refactoring.
# the overhead is acceptable for now
self.clean_model()
return False
currentSong = playlist.get_value(currentIter, 5)
song_passed = False
itr = playlist.get_iter_first()
while itr:
song = playlist.get_value(itr, 5)
song_widget = song.song_widget
if not song_widget.can_be_played:
itr = playlist.iter_next(itr)
continue
escapedTitle = AlbumArtCache.get_media_title(song, True)
if (song == currentSong):
song_widget.now_playing_sign.show()
song_widget.title.set_markup('<b>%s</b>' % escapedTitle)
song_passed = True
elif (song_passed):
song_widget.now_playing_sign.hide()
song_widget.title.set_markup('<span>%s</span>' % escapedTitle)
else:
song_widget.now_playing_sign.hide()
song_widget.title\
.set_markup('<span color=\'grey\'>%s</span>' % escapedTitle)
itr = playlist.iter_next(itr)
return False
def _add_item(self, source, param, item):
if not item:
return
self._offset += 1
artist = item.get_string(Grl.METADATA_KEY_ARTIST)\
or item.get_author()\
or _("Unknown Artist")
title = albumArtCache.get_media_title(item)
item.set_title(title)
def add_new_item():
_iter = self._model.append()
icon_name = self.nowPlayingIconName
if item.get_url():
try:
self.player.discoverer.discover_uri(item.get_url())
except:
print('failed to discover url ' + item.get_url())
icon_name = self.errorIconName
self._model.set(_iter,
[0, 1, 2, 3, 4, 5, 7, 8, 9, 10],
[str(item.get_id()), '', title,
artist, self._symbolicIcon, item,
-1, icon_name, False, icon_name == self.errorIconName])
GLib.idle_add(self._update_album_art, item, _iter)
GLib.idle_add(add_new_item)
def _update_track(self, player):
if not self._player.currentTrack:
self._notification.update(_("Not playing"), None, 'gnome-music')
self._notification.set_hint('image-data', None)
self._notification.show()
else:
item = self._player.get_current_media()
if not item:
return
artist = item.get_string(Grl.METADATA_KEY_ARTIST)\
or item.get_author()\
or _("Unknown Artist")
album = item.get_string(Grl.METADATA_KEY_ALBUM)\
or _("Unknown Album")
self._notification.update(AlbumArtCache.get_media_title(item),
# TRANSLATORS: by refers to the artist, from to the album
_("by %s, from %s") % ('<b>' + artist + '</b>',
'<i>' + album + '</i>'),
'gnome-music')
try:
self._notification.show()
except:
pass
def __init__(self, artist, album, player, model):
super(Gtk.HBox, self).__init__()
self.player = player
self.album = album
self.artist = artist
self.model = model
self.songs = []
self.monitors = []
self.ui = Gtk.Builder()
self.ui.add_from_resource('/org/gnome/Music/ArtistAlbumWidget.ui')
self.cache = AlbumArtCache.get_default()
pixbuf = self.cache.get_default_icon(128, 128)
GLib.idle_add(self._update_album_art)
self.ui.get_object('cover').set_from_pixbuf(pixbuf)
self.ui.get_object('title').set_label(album.get_title())
if album.get_creation_date():
self.ui.get_object('year').set_markup(
'<span color=\'grey\'>(%s)</span>' %
str(album.get_creation_date().get_year())
)
self.tracks = []
GLib.idle_add(grilo.populate_album_songs,
album.get_id(), self.get_songs)
self.pack_start(self.ui.get_object('ArtistAlbumWidget'), True, True, 0)
self.show_all()
def update_model(self, player, playlist, currentIter):
# self is not our playlist, return
if (playlist != self.model):
return False
currentSong = playlist.get_value(currentIter, 5)
song_passed = False
_iter = playlist.get_iter_first()
self.duration = 0
while _iter:
song = playlist.get_value(_iter, 5)
self.duration += song.get_duration()
escapedTitle = AlbumArtCache.get_media_title(song, True)
if (song == currentSong):
title = '<b>%s</b>' % escapedTitle
iconVisible = True
song_passed = True
elif (song_passed):
title = '<span>%s</span>' % escapedTitle
iconVisible = False
else:
title = '<span color=\'grey\'>%s</span>' % escapedTitle
iconVisible = False
playlist.set_value(_iter, 0, title)
if(playlist.get_value(_iter, 7) != ERROR_ICON_NAME):
playlist.set_value(_iter, 9, iconVisible)
_iter = playlist.iter_next(_iter)
self.ui.get_object('running_length_label_info').set_text(
'%d min' % (int(self.duration / 60) + 1))
return False
def _add_item_to_model(self, item, model):
if not item:
return
self._offset += 1
item.set_title(albumArtCache.get_media_title(item))
artist = item.get_string(Grl.METADATA_KEY_ARTIST)\
or item.get_author()\
or _("Unknown Artist")
_iter = model.insert_with_valuesv(
-1,
[2, 3, 5, 8, 9, 10],
[albumArtCache.get_media_title(item),
artist, item, self.nowPlayingIconName, False, False])
self.player.discover_item(item, self._on_discovered, _iter)
self.songs_count += 1
self._update_songs_count()
def __init__(self, player):
self._player = player
self._notification = Notify.Notification()
self._notification.set_category('x-gnome.music')
self._notification.set_hint('action-icons', GLib.Variant('b', True))
self._notification.set_hint('resident', GLib.Variant('b', True))
self._notification.set_hint('desktop-entry', GLib.Variant('s', 'gnome-music'))
self._isPlaying = False
self._albumArtCache = AlbumArtCache.get_default()
self._noArtworkIcon = self._albumArtCache.get_default_icon(IMAGE_SIZE, IMAGE_SIZE)
rowStride = self._noArtworkIcon.get_rowstride()
hasAlpha = self._noArtworkIcon.get_has_alpha()
bitsPerSample = self._noArtworkIcon.get_bits_per_sample()
nChannels = self._noArtworkIcon.get_n_channels()
data = self._noArtworkIcon.get_pixels()
self._noArtworkIconSerialized = GLib.Variant(
'(iiibiiay)',
(IMAGE_SIZE, IMAGE_SIZE, rowStride, hasAlpha, bitsPerSample, nChannels, data))
self._player.connect('playing-changed', self._on_playing_changed)
self._player.connect('current-changed', self._update_track)
self._player.connect('thumbnail-updated', self._on_thumbnail_updated)
def __init__(self):
GObject.GObject.__init__(self)
self.playlist = None
self.playlistType = None
self.playlistId = None
self.playlistField = None
self.currentTrack = None
self._lastState = Gst.State.PAUSED
self.cache = AlbumArtCache.get_default()
self._symbolicIcon = self.cache.get_default_icon(ART_SIZE, ART_SIZE)
Gst.init(None)
self.discoverer = GstPbutils.Discoverer()
self.discoverer.connect('discovered', self._on_discovered)
self.discoverer.start()
self._discovering_urls = {}
self.player = Gst.ElementFactory.make('playbin', 'player')
self.bus = self.player.get_bus()
self.bus.add_signal_watch()
self._settings = Gio.Settings.new('org.gnome.Music')
self._settings.connect('changed::repeat', self._on_settings_changed)
self.repeat = self._settings.get_enum('repeat')
self.bus.connect('message::state-changed', self._on_bus_state_changed)
self.bus.connect('message::error', self._onBusError)
self.bus.connect('message::eos', self._on_bus_eos)
self._setup_view()
self.playlist_insert_handler = 0
self.playlist_delete_handler = 0
def update_model(self, player, playlist, currentIter):
#self is not our playlist, return
if (playlist != self.model):
return False
currentSong = playlist.get_value(currentIter, 5)
song_passed = False
_iter = playlist.get_iter_first()
while _iter:
song = playlist.get_value(_iter, 5)
escapedTitle = AlbumArtCache.get_media_title(song, True)
if (song == currentSong):
title = "<b>%s</b>" % escapedTitle
iconVisible = True
song_passed = True
elif (song_passed):
title = "<span>%s</span>" % escapedTitle
iconVisible = False
else:
title = "<span color='grey'>%s</span>" % escapedTitle
iconVisible = False
playlist.set_value(_iter, 0, title)
if(playlist.get_value(_iter, 7) != ERROR_ICON_NAME):
playlist.set_value(_iter, 9, iconVisible)
_iter = playlist.iter_next(_iter)
return False
def update_model(self, player, playlist, currentIter):
# this is not our playlist, return
if playlist != self.model:
# TODO, only clean once, but that can wait util we have clean
# the code a bit, and until the playlist refactoring.
# the overhead is acceptable for now
self.clean_model()
return False
currentSong = playlist.get_value(currentIter, 5)
song_passed = False
itr = playlist.get_iter_first()
while itr:
song = playlist.get_value(itr, 5)
song_widget = song.song_widget
if not song_widget.can_be_played:
itr = playlist.iter_next(itr)
continue
escapedTitle = AlbumArtCache.get_media_title(song, True)
if (song == currentSong):
song_widget.now_playing_sign.show()
song_widget.title.set_markup('<b>%s</b>' % escapedTitle)
song_passed = True
elif (song_passed):
song_widget.now_playing_sign.hide()
song_widget.title.set_markup('<span>%s</span>' % escapedTitle)
else:
song_widget.now_playing_sign.hide()
song_widget.title\
.set_markup('<span color=\'grey\'>%s</span>' % escapedTitle)
itr = playlist.iter_next(itr)
return False
def __init__(self, player):
super(Gtk.EventBox, self).__init__()
self.player = player
self.iterToClean = None
self.cache = AlbumArtCache.get_default()
self.ui = Gtk.Builder()
self.ui.add_from_resource('/org/gnome/Music/AlbumWidget.ui')
self._create_model()
self.view = Gd.MainView(
shadow_type=Gtk.ShadowType.NONE
)
self.view.set_view_type(Gd.MainViewType.LIST)
self.album = None
self.view.connect('item-activated', self._on_item_activated)
self.monitors = []
view_box = self.ui.get_object('view')
self.ui.get_object('scrolledWindow').set_placement(Gtk.CornerType.
TOP_LEFT)
child_view = self.view.get_children()[0]
child_view.set_margin_top(64)
child_view.set_margin_bottom(64)
child_view.set_margin_right(32)
self.view.remove(child_view)
view_box.add(child_view)
self.add(self.ui.get_object('AlbumWidget'))
self._add_list_renderers()
# TODO: make this work
self.get_style_context().add_class('view')
self.get_style_context().add_class('content-view')
self.show_all()
def _get_active_playlist(self):
playlist = self._get_playlist_from_id(self.player.playlistId) \
if self.player.playlistType == 'Playlist' else None
playlistName = AlbumArtCache.get_media_title(playlist) \
if playlist else ''
return (playlist is not None,
(self._get_playlist_path(playlist), playlistName, ''))
def _get_active_playlist(self):
playlist = self._get_playlist_from_id(self.player.playlistId) \
if self.player.playlistType == 'Playlist' else None
playlistName = AlbumArtCache.get_media_title(playlist) \
if playlist else ''
return (playlist is not None, (self._get_playlist_path(playlist),
playlistName, ''))
def load(self, media):
self._set_duration(media.get_duration())
self.songTotalTimeLabel.set_label(self.seconds_to_string(media.get_duration()))
self.progressScale.set_sensitive(True)
self.playBtn.set_sensitive(True)
self._sync_prev_next()
self.coverImg.set_from_pixbuf(self._symbolicIcon)
self.cache.lookup(media, ART_SIZE, ART_SIZE, self._on_cache_lookup)
self.titleLabel.set_label(AlbumArtCache.get_media_title(media))
if media.get_artist() is not None:
self.artistLabel.set_label(media.get_artist())
else:
self.artistLabel.set_label(_("Unknown Artist"))
url = media.get_url()
if url != self.player.get_value('current-uri', 0):
self.player.set_property('uri', url)
currentTrack = self.playlist.get_iter(self.currentTrack.get_path())
self.emit('playlist-item-changed', self.playlist, currentTrack)
self.emit('current-changed')
def add_new_item():
_iter = self._model.append(None)
icon_name = self.nowPlayingIconName
if item.get_url():
try:
self.player.discoverer.discover_uri(item.get_url())
except:
print('failed to discover url ' + item.get_url())
icon_name = self.errorIconName
self._model.set(_iter,
[0, 1, 2, 3, 4, 5, 7, 8, 9, 10],
[str(item.get_id()), '', title,
artist, self._symbolicIcon, item,
0, icon_name, False, icon_name == self.errorIconName])
albumArtCache.get_default().lookup(
item, self._iconWidth, self._iconHeight, self._on_lookup_ready,
_iter, artist, title)
def _add_item_to_model(self, item):
new_iter = self.model.insert_before(self.add_playlist_iter)
self.model.set(
new_iter,
[0, 1, 2],
[AlbumArtCache.get_media_title(item), False, item]
)
return new_iter
def GetPlaylists(self, index, max_count, order, reverse):
if order != 'Alphabetical':
return []
playlists = [(self._get_playlist_path(playlist),
AlbumArtCache.get_media_title(playlist) or '', '')
for playlist in self.playlists]
return playlists[index:index + max_count] if not reverse \
else playlists[index + max_count - 1:index - 1 if index - 1 >= 0 else None:-1]
def GetPlaylists(self, index, max_count, order, reverse):
if order != 'Alphabetical':
return []
playlists = [(self._get_playlist_path(playlist),
AlbumArtCache.get_media_title(playlist) or '', '')
for playlist in self.playlists]
return playlists[index:index + max_count] if not reverse \
else playlists[index + max_count - 1:index - 1 if index - 1 >= 0 else None:-1]
def _add_item_to_model(self, item):
new_iter = self.model.insert_before(self.add_playlist_iter)
self.model.set(
new_iter,
[0, 1, 2],
[AlbumArtCache.get_media_title(item), False, item]
)
return new_iter
def _add_item(self, source, param, item):
if not item:
return
self._offset += 1
item.set_title(albumArtCache.get_media_title(item))
artist = item.get_string(Grl.METADATA_KEY_ARTIST)\
or item.get_author()\
or _("Unknown Artist")
_iter = self._model.insert_with_valuesv(-1, [2, 3, 5, 8, 9, 10], [
albumArtCache.get_media_title(item), artist, item,
self.nowPlayingIconName, False, False
])
self.player.discover_item(item, self._on_discovered, _iter)
g_file = Gio.file_new_for_uri(item.get_url())
self.monitors.append(
g_file.monitor_file(Gio.FileMonitorFlags.NONE, None))
self.monitors[(self._offset - 1)].connect('changed',
self._on_item_changed, _iter)
def _add_item(self, source, param, item):
if not item:
return
self._offset += 1
item.set_title(albumArtCache.get_media_title(item))
artist = item.get_string(Grl.METADATA_KEY_ARTIST)\
or item.get_author()\
or _("Unknown Artist")
_iter = self._model.insert_with_valuesv(
-1,
[2, 3, 5, 8, 9, 10],
[albumArtCache.get_media_title(item),
artist, item, self.nowPlayingIconName, False, False])
self.player.discover_item(item, self._on_discovered, _iter)
g_file = Gio.file_new_for_uri(item.get_url())
self.monitors.append(g_file.monitor_file(Gio.FileMonitorFlags.NONE,
None))
self.monitors[(self._offset - 1)].connect('changed',
self._on_item_changed, _iter)
def clean_model(self):
itr = self.model.get_iter_first()
while itr:
song = self.model.get_value(itr, 5)
song_widget = song.song_widget
escapedTitle = AlbumArtCache.get_media_title(song, True)
if song_widget.can_be_played:
song_widget.now_playing_sign.hide()
song_widget.title.set_markup('<span>%s</span>' % escapedTitle)
itr = self.model.iter_next(itr)
return False
def clean_model(self):
itr = self.model.get_iter_first()
while itr:
song = self.model.get_value(itr, 5)
song_widget = song.song_widget
escapedTitle = AlbumArtCache.get_media_title(song, True)
if song_widget.can_be_played:
song_widget.now_playing_sign.hide()
song_widget.title.set_markup('<span>%s</span>' % escapedTitle)
itr = self.model.iter_next(itr)
return False
def get_songs(self, source, prefs, track):
if track:
self.tracks.append(track)
else:
for i, track in enumerate(self.tracks):
ui = Gtk.Builder()
ui.add_from_resource('/org/gnome/Music/TrackWidget.ui')
song_widget = ui.get_object("eventbox1")
self.songs.append(song_widget)
ui.get_object("num")\
.set_markup("<span color='grey'>%d</span>"
% len(self.songs))
title = AlbumArtCache.get_media_title(track)
ui.get_object("title").set_text(title)
ui.get_object("title").set_alignment(0.0, 0.5)
self.ui.get_object("grid1").attach(
song_widget,
int(i / (len(self.tracks) / 2)),
int(i % (len(self.tracks) / 2)), 1, 1
)
track.song_widget = song_widget
itr = self.model.append()
song_widget._iter = itr
song_widget.model = self.model
song_widget.title = ui.get_object("title")
try:
self.player.discoverer.discover_uri(str(track.get_url()))
self.model.set(itr,
[0, 1, 2, 3, 4, 5],
[title, "", "", False,
NOW_PLAYING_ICON_NAME, track])
song_widget.now_playing_sign = ui.get_object("image1")
song_widget.now_playing_sign.set_from_icon_name(
NOW_PLAYING_ICON_NAME,
Gtk.IconSize.SMALL_TOOLBAR)
song_widget.now_playing_sign.set_no_show_all("True")
song_widget.now_playing_sign.set_alignment(0.0, 0.6)
song_widget.can_be_played = True
song_widget.connect('button-release-event',
self.track_selected)
except:
print("failed to discover url " + str(track.get_url()))
self.model.set(itr, [0, 1, 2, 3, 4, 5],
[title, "", "", True,
ERROR_ICON_NAME, track])
song_widget.now_playing_sign = ui.get_object("image1")
song_widget.now_playing_sign.set_from_icon_name(
ERROR_ICON_NAME,
Gtk.IconSize.SMALL_TOOLBAR)
song_widget.now_playing_sign.set_alignment(0.0, 0.6)
song_widget.can_be_played = False
self.ui.get_object("grid1").show_all()
def _on_item_activated(self, widget, id, path):
_iter = self.model.get_iter(path)
if(self.model.get_value(_iter, 7) != ERROR_ICON_NAME):
if (self.iterToClean and self.player.playlistId == self.album):
item = self.model.get_value(self.iterToClean, 5)
title = AlbumArtCache.get_media_title(item)
self.model.set_value(self.iterToClean, 0, title)
#Hide now playing icon
self.model.set_value(self.iterToClean, 6, False)
self.player.set_playlist("Album", self.album, self.model, _iter, 5)
self.player.set_playing(True)
def _add_item(self, source, param, item):
if item:
self._offset += 1
_iter = self._model.append()
item.set_title(albumArtCache.get_media_title(item))
try:
if item.get_url():
self.player.discoverer.discover_uri(item.get_url())
self._model.set(_iter,
[2, 3, 5, 8, 9, 10],
[albumArtCache.get_media_title(item),
item.get_string(Grl.METADATA_KEY_ARTIST),
item, self.nowPlayingIconName, False, False])
except:
print("failed to discover url " + item.get_url())
self._model.set(_iter,
[2, 3, 5, 8, 9, 10],
[albumArtCache.get_media_title(item),
item.get_string(Grl.METADATA_KEY_ARTIST),
item, self.errorIconName, False, True])
def _on_item_activated(self, widget, id, path):
_iter = self._model.get_iter(path)
title = self._model.get_value(_iter, 2)
artist = self._model.get_value(_iter, 3)
item = self._model.get_value(_iter, 5)
self._albumWidget.update(artist, title, item,
self.header_bar, self.selection_toolbar)
self.header_bar.set_state(0)
escaped_title = albumArtCache.get_media_title(item)
self.header_bar.header_bar.set_title(escaped_title)
self.header_bar.header_bar.sub_title = artist
self.set_visible_child(self._albumWidget)
def _on_item_activated(self, widget, id, path):
child_path = self.filter.convert_path_to_child_path(path)
_iter = self._model.get_iter(child_path)
title = self._model.get_value(_iter, 2)
artist = self._model.get_value(_iter, 3)
item = self._model.get_value(_iter, 5)
self._albumWidget.update(artist, title, item, self.header_bar,
self.selection_toolbar)
self.header_bar.set_state(0)
escaped_title = albumArtCache.get_media_title(item)
self.header_bar.header_bar.set_title(escaped_title)
self.header_bar.header_bar.sub_title = artist
self.set_visible_child(self._albumWidget)
def add_item(self, source, prefs, track, remaining, data=None):
if track:
self.tracks.append(track)
self.duration = self.duration + track.get_duration()
_iter = self.model.append()
escapedTitle = AlbumArtCache.get_media_title(track, True)
self.model.set(_iter,
[0, 1, 2, 3, 4, 5, 10],
[escapedTitle,
self.player.seconds_to_string(
track.get_duration()),
'', '', None, track, bool(track.get_lyrics())])
self.ui.get_object('running_length_label_info').set_text(
_("%d min") % (int(self.duration / 60) + 1))
def add_item(self, source, prefs, track, remaining, data=None):
if track:
self.tracks.append(track)
self.duration = self.duration + track.get_duration()
_iter = self.model.append()
escapedTitle = AlbumArtCache.get_media_title(track, True)
self.model.set(_iter, [0, 1, 2, 3, 4, 5, 9], [
escapedTitle,
self.player.seconds_to_string(track.get_duration()), '', '',
None, track,
bool(track.get_lyrics())
])
self.ui.get_object('running_length_label_info').set_text(
_("%d min") % (int(self.duration / 60) + 1))
def add_item(self, source, prefs, track, remaining, data=None):
if remaining == 0:
self.songsGrid.show_all()
self.emit("tracks-loaded")
if track:
self.tracks.append(track)
else:
for i, track in enumerate(self.tracks):
ui = Gtk.Builder()
ui.add_from_resource('/org/gnome/Music/TrackWidget.ui')
song_widget = ui.get_object('eventbox1')
self.songs.append(song_widget)
ui.get_object('num')\
.set_markup('<span color=\'grey\'>%d</span>'
% len(self.songs))
title = AlbumArtCache.get_media_title(track)
ui.get_object('title').set_text(title)
ui.get_object('title').set_alignment(0.0, 0.5)
ui.get_object('title').set_max_width_chars(MAX_TITLE_WIDTH)
self.songsGrid.attach(
song_widget,
int(i / (len(self.tracks) / 2)),
int(i % (len(self.tracks) / 2)), 1, 1
)
track.song_widget = song_widget
itr = self.model.append(None)
song_widget._iter = itr
song_widget.model = self.model
song_widget.title = ui.get_object('title')
song_widget.checkButton = ui.get_object('select')
song_widget.checkButton.set_visible(self.selectionMode)
song_widget.checkButton.connect(
'toggled', self._check_button_toggled, song_widget
)
self.player.discover_item(track, self._on_discovered, song_widget)
self.model.set(itr,
[0, 1, 2, 3, 4, 5],
[title, '', '', False,
NOW_PLAYING_ICON_NAME, track])
song_widget.now_playing_sign = ui.get_object('image1')
song_widget.now_playing_sign.set_from_icon_name(
NOW_PLAYING_ICON_NAME,
Gtk.IconSize.SMALL_TOOLBAR)
song_widget.now_playing_sign.set_no_show_all('True')
song_widget.now_playing_sign.set_alignment(1, 0.6)
song_widget.can_be_played = True
song_widget.connect('button-release-event',
self.track_selected)
def add_item(self, source, prefs, track, remaining, data=None):
if remaining == 0:
self.songsGrid.show_all()
self.emit("tracks-loaded")
if track:
self.tracks.append(track)
else:
for i, track in enumerate(self.tracks):
ui = Gtk.Builder()
ui.add_from_resource('/org/gnome/Music/TrackWidget.ui')
song_widget = ui.get_object('eventbox1')
self.songs.append(song_widget)
ui.get_object('num')\
.set_markup('<span color=\'grey\'>%d</span>'
% len(self.songs))
title = AlbumArtCache.get_media_title(track)
ui.get_object('title').set_text(title)
ui.get_object('title').set_alignment(0.0, 0.5)
ui.get_object('title').set_max_width_chars(MAX_TITLE_WIDTH)
self.songsGrid.attach(
song_widget,
int(i / (len(self.tracks) / 2)),
int(i % (len(self.tracks) / 2)), 1, 1
)
track.song_widget = song_widget
itr = self.model.append(None)
song_widget._iter = itr
song_widget.model = self.model
song_widget.title = ui.get_object('title')
song_widget.checkButton = ui.get_object('select')
song_widget.checkButton.set_visible(self.selectionMode)
song_widget.checkButton.connect(
'toggled', self._check_button_toggled, song_widget
)
self.model.set(itr,
[0, 1, 2, 3, 5],
[title, '', '', False, track])
song_widget.now_playing_sign = ui.get_object('image1')
song_widget.now_playing_sign.set_from_icon_name(
NOW_PLAYING_ICON_NAME,
Gtk.IconSize.SMALL_TOOLBAR)
song_widget.now_playing_sign.set_no_show_all('True')
song_widget.now_playing_sign.set_alignment(1, 0.6)
song_widget.can_be_played = True
song_widget.connect('button-release-event',
self.track_selected)
def __init__(self, parent_window):
GObject.GObject.__init__(self)
self._parent_window = parent_window
self.playlist = None
self.playlistType = None
self.playlistId = None
self.playlistField = None
self.currentTrack = None
self.currentTrackUri = None
self._lastState = Gst.State.PAUSED
self.cache = AlbumArtCache.get_default()
self._noArtworkIcon = self.cache.get_default_icon(ART_SIZE, ART_SIZE)
self._loadingIcon = self.cache.get_default_icon(
ART_SIZE, ART_SIZE, True)
self._missingPluginMessages = []
Gst.init(None)
GstPbutils.pb_utils_init()
self.discoverer = GstPbutils.Discoverer()
self.discoverer.connect('discovered', self._on_discovered)
self.discoverer.start()
self._discovering_urls = {}
self.player = Gst.ElementFactory.make('playbin', 'player')
self.bus = self.player.get_bus()
self.bus.add_signal_watch()
self.setup_replaygain()
self._settings = Gio.Settings.new('org.gnome.Music')
self._settings.connect('changed::repeat',
self._on_repeat_setting_changed)
self._settings.connect('changed::replaygain',
self._on_replaygain_setting_changed)
self.repeat = self._settings.get_enum('repeat')
self.replaygain = self._settings.get_value('replaygain') is not None
self.toggle_replaygain(self.replaygain)
self.bus.connect('message::state-changed', self._on_bus_state_changed)
self.bus.connect('message::error', self._onBusError)
self.bus.connect('message::element', self._on_bus_element)
self.bus.connect('message::eos', self._on_bus_eos)
self._setup_view()
self.playlist_insert_handler = 0
self.playlist_delete_handler = 0
self._check_last_fm()
def _on_item_activated(self, widget, id, path):
if self.star_handler.star_renderer_click:
self.star_handler.star_renderer_click = False
return
_iter = self.model.get_iter(path)
if self.model.get_value(_iter, 10) != DiscoveryStatus.FAILED:
if (self.iterToClean and self.player.playlistId == self.album):
item = self.model.get_value(self.iterToClean, 5)
title = AlbumArtCache.get_media_title(item)
self.model.set_value(self.iterToClean, 0, title)
# Hide now playing icon
self.model.set_value(self.iterToClean, 6, False)
self.player.set_playlist('Album', self.album, self.model, _iter, 5, 11)
self.player.set_playing(True)
def __init__(self, player):
self._player = player
self._notification = Notify.Notification()
self._notification.set_category('x-gnome.music')
self._notification.set_hint('action-icons', GLib.Variant('b', True))
self._notification.set_hint('resident', GLib.Variant('b', True))
self._notification.set_hint('desktop-entry',
GLib.Variant('s', 'gnome-music'))
self._isPlaying = False
self._albumArtCache = AlbumArtCache.get_default()
self._noArtworkIcon = self._albumArtCache.get_default_icon(
IMAGE_SIZE, IMAGE_SIZE)
self._noArtworkIconSerialized = None
def load(self, media):
self.progressScale.set_value(0)
self._set_duration(media.get_duration())
self.songTotalTimeLabel.set_label(
self.seconds_to_string(media.get_duration()))
self.progressScale.set_sensitive(True)
self.playBtn.set_sensitive(True)
self._sync_prev_next()
artist = _("Unknown Artist")
try:
assert media.get_artist() is not None
artist = media.get_artist()
except:
pass
finally:
self.artistLabel.set_label(artist)
self._currentArtist = artist
album = _("Unknown Album")
try:
assert media.get_album() is not None
album = media.get_album()
except:
self._currentAlbum = album
self.coverImg.set_from_pixbuf(self._noArtworkIcon)
self.cache.lookup(media, ART_SIZE, ART_SIZE, self._on_cache_lookup,
None, artist, album)
self._currentTitle = AlbumArtCache.get_media_title(media)
self.titleLabel.set_label(self._currentTitle)
self._currentTimestamp = int(time.time())
url = media.get_url()
if url != self.player.get_value('current-uri', 0):
self.player.set_property('uri', url)
if self.currentTrack and self.currentTrack.valid():
currentTrack = self.playlist.get_iter(self.currentTrack.get_path())
self.emit('playlist-item-changed', self.playlist, currentTrack)
self.emit('current-changed')
self._validate_next_track()
def __init__(self, header_bar, selection_toolbar, player):
ViewContainer.__init__(self, _("Songs"), header_bar, selection_toolbar)
self.countQuery = Query.SONGS_COUNT
self._items = {}
self.monitors = []
self.isStarred = None
self.iter_to_clean = None
self.view.set_view_type(Gd.MainViewType.LIST)
self.view.get_generic_view().get_style_context()\
.add_class('songs-list')
self._iconHeight = 32
self._iconWidth = 32
self.cache = albumArtCache.get_default()
self._symbolicIcon = self.cache.make_default_icon(
self._iconHeight, self._iconWidth)
self._add_list_renderers()
self.player = player
self.player.connect('playlist-item-changed', self.update_model)
def __init__(self, player):
self._player = player
self._notification = Notify.Notification()
self._notification.set_category('x-gnome.music')
self._notification.set_hint('action-icons', GLib.Variant('b', True))
self._notification.set_hint('resident', GLib.Variant('b', True))
self._notification.set_hint('desktop-entry',
GLib.Variant('s', 'gnome-music'))
self._isPlaying = False
self._albumArtCache = AlbumArtCache.get_default()
self._symbolicIcon = self._albumArtCache.make_default_icon(
IMAGE_SIZE, IMAGE_SIZE)
self._player.connect('playing-changed', self._on_playing_changed)
self._player.connect('current-changed', self._update_track)
def _get_metadata(self):
media = self.player.get_current_media()
if not media:
return {}
metadata = {
'mpris:trackid':
'/org/mpris/MediaPlayer2/Track/%s' % media.get_id(),
'xesam:url': media.get_url(),
'mpris:length': dbus.Int64(media.get_duration() * 1000000),
'xesam:trackNumber': media.get_track_number(),
'xesam:useCount': media.get_play_count(),
'xesam:userRating': media.get_rating(),
}
title = AlbumArtCache.get_media_title(media)
if title:
metadata['xesam:title'] = title
album = media.get_album()
if album:
metadata['xesam:album'] = album
artist = media.get_artist()
if artist:
metadata['xesam:artist'] = [artist]
metadata['xesam:albumArtist'] = [artist]
genre = media.get_genre()
if genre:
metadata['xesam:genre'] = [genre]
last_played = media.get_last_played()
if last_played:
metadata['xesam:lastUsed'] = last_played
thumbnail = media.get_thumbnail()
if thumbnail:
metadata['mpris:artUrl'] = thumbnail
return metadata
def _update_track(self, player):
if not self._player.currentTrack:
self._notification.update(_("Not playing"), None, 'gnome-music')
self._notification.set_hint('image-data', None)
self._notification.show()
else:
item = self._player.get_current_media()
artist = item.get_string(Grl.METADATA_KEY_ARTIST)\
or item.get_author()\
or _("Unknown Artist")
album = item.get_string(Grl.METADATA_KEY_ALBUM)\
or _("Unknown Album")
self._notification.update(
AlbumArtCache.get_media_title(item),
# TRANSLATORS: by refers to the artist, from to the album
_("by %s, from %s") %
('<b>' + artist + '</b>', '<i>' + album + '</i>'),
'gnome-music')
self._albumArtCache.lookup(item, IMAGE_SIZE, IMAGE_SIZE,
self._album_art_loaded)
def __init__(self, title, header_bar, selection_toolbar, useStack=False):
Stack.__init__(self, transition_type=StackTransitionType.CROSSFADE)
self._grid = Gtk.Grid(orientation=Gtk.Orientation.VERTICAL)
self._iconWidth = -1
self._iconHeight = 128
self._offset = 0
self._adjustmentValueId = 0
self._adjustmentChangedId = 0
self._scrollbarVisibleId = 0
self._model = Gtk.ListStore(GObject.TYPE_STRING, GObject.TYPE_STRING,
GObject.TYPE_STRING, GObject.TYPE_STRING,
GdkPixbuf.Pixbuf, GObject.TYPE_OBJECT,
GObject.TYPE_BOOLEAN, GObject.TYPE_INT,
GObject.TYPE_STRING, GObject.TYPE_BOOLEAN,
GObject.TYPE_BOOLEAN)
self.view = Gd.MainView(shadow_type=Gtk.ShadowType.NONE)
self.view.set_view_type(Gd.MainViewType.ICON)
self.view.set_model(self._model)
self.filter = self._model.filter_new(None)
self.view.set_model(self.filter)
self.vadjustment = self.view.get_vadjustment()
self.selection_toolbar = selection_toolbar
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
box.pack_start(self.view, True, True, 0)
if useStack:
self.stack = Stack(
transition_type=StackTransitionType.SLIDE_RIGHT, )
dummy = Gtk.Frame(visible=False)
self.stack.add_named(dummy, 'dummy')
self.stack.add_named(box, 'artists')
self.stack.set_visible_child_name('dummy')
self._grid.add(self.stack)
else:
self._grid.add(box)
self._cached_count = -1
self._loadMore = Widgets.LoadMoreButton(self._get_remaining_item_count)
box.pack_end(self._loadMore.widget, False, False, 0)
self._loadMore.widget.connect('clicked', self._populate)
self.view.connect('item-activated', self._on_item_activated)
self.view.connect('selection-mode-request',
self._on_selection_mode_request)
self._cursor = None
self.header_bar = header_bar
self.header_bar._select_button.connect('toggled',
self._on_header_bar_toggled)
self.header_bar._cancel_button.connect('clicked',
self._on_cancel_button_clicked)
self.title = title
self.add(self._grid)
self.show_all()
self._items = []
self._loadMore.widget.hide()
self._connect_view()
self.cache = albumArtCache.get_default()
self._symbolicIcon = self.cache.make_default_icon(
self._iconHeight, self._iconWidth)
self._init = False
grilo.connect('ready', self._on_grilo_ready)
self.header_bar.header_bar.connect('state-changed',
self._on_state_changed)
self.view.connect('view-selection-changed',
self._on_view_selection_changed)
self._discovering_urls = {}
class ArtistAlbumWidget(Gtk.Box):
__gsignals__ = {
'tracks-loaded': (GObject.SignalFlags.RUN_FIRST, None, ()),
}
loadingIcon = AlbumArtCache.get_default().get_default_icon(128, 128, True)
noArtworkIcon = ALBUM_ART_CACHE.get_default_icon(128, 128, False)
def __repr__(self):
return '<ArtistAlbumWidget>'
@log
def __init__(self, artist, album, player, model, header_bar,
selectionModeAllowed):
Gtk.Box.__init__(self, orientation=Gtk.Orientation.HORIZONTAL)
self.player = player
self.album = album
self.artist = artist
self.model = model
self.model.connect('row-changed', self._model_row_changed)
self.header_bar = header_bar
self.selectionMode = False
self.selectionModeAllowed = selectionModeAllowed
self.songs = []
self.ui = Gtk.Builder()
self.ui.add_from_resource('/org/gnome/Music/ArtistAlbumWidget.ui')
GLib.idle_add(self._update_album_art)
self.cover = self.ui.get_object('cover')
self.cover.set_from_pixbuf(self.loadingIcon)
self.songsGrid = self.ui.get_object('grid1')
self.ui.get_object('title').set_label(album.get_title())
if album.get_creation_date():
self.ui.get_object('year').set_markup(
'<span color=\'grey\'>(%s)</span>' %
str(album.get_creation_date().get_year()))
self.tracks = []
grilo.populate_album_songs(album, self.add_item)
self.pack_start(self.ui.get_object('ArtistAlbumWidget'), True, True, 0)
@log
def add_item(self, source, prefs, track, remaining, data=None):
if remaining == 0:
self.songsGrid.show_all()
self.emit("tracks-loaded")
if track:
self.tracks.append(track)
else:
for i, track in enumerate(self.tracks):
ui = Gtk.Builder()
ui.add_from_resource('/org/gnome/Music/TrackWidget.ui')
song_widget = ui.get_object('eventbox1')
self.songs.append(song_widget)
ui.get_object('num')\
.set_markup('<span color=\'grey\'>%d</span>'
% len(self.songs))
title = AlbumArtCache.get_media_title(track)
ui.get_object('title').set_text(title)
ui.get_object('title').set_alignment(0.0, 0.5)
ui.get_object('title').set_max_width_chars(MAX_TITLE_WIDTH)
self.songsGrid.attach(song_widget,
int(i / (len(self.tracks) / 2)),
int(i % (len(self.tracks) / 2)), 1, 1)
track.song_widget = song_widget
itr = self.model.append(None)
song_widget._iter = itr
song_widget.model = self.model
song_widget.title = ui.get_object('title')
song_widget.checkButton = ui.get_object('select')
song_widget.checkButton.set_visible(self.selectionMode)
song_widget.checkButton.connect('toggled',
self._check_button_toggled,
song_widget)
self.model.set(itr, [0, 1, 2, 3, 5],
[title, '', '', False, track])
song_widget.now_playing_sign = ui.get_object('image1')
song_widget.now_playing_sign.set_from_icon_name(
NOW_PLAYING_ICON_NAME, Gtk.IconSize.SMALL_TOOLBAR)
song_widget.now_playing_sign.set_no_show_all('True')
song_widget.now_playing_sign.set_alignment(1, 0.6)
song_widget.can_be_played = True
song_widget.connect('button-release-event',
self.track_selected)
@log
def _update_album_art(self):
real_artist = self.album.get_string(Grl.METADATA_KEY_ARTIST)\
or self.album.get_author()\
or _("Unknown Artist")
ALBUM_ART_CACHE.lookup(self.album, 128, 128, self._get_album_cover,
None, real_artist, self.album.get_title())
@log
def _get_album_cover(self, pixbuf, path, data=None):
if not pixbuf:
pixbuf = self.noArtworkIcon
self.cover.set_from_pixbuf(pixbuf)
@log
def track_selected(self, widget, event):
if not widget.can_be_played:
return
if not self.selectionMode and \
(event.button == Gdk.BUTTON_SECONDARY or
(event.button == 1 and event.state & Gdk.ModifierType.CONTROL_MASK)):
if self.selectionModeAllowed:
self.header_bar._select_button.set_active(True)
else:
return
if self.selectionMode:
self.model[widget._iter][6] = not self.model[widget._iter][6]
return
self.player.stop()
self.player.set_playlist('Artist', self.artist, widget.model,
widget._iter, 5, 6)
self.player.set_playing(True)
@log
def set_selection_mode(self, selectionMode):
if self.selectionMode == selectionMode:
return
self.selectionMode = selectionMode
for songWidget in self.songs:
songWidget.checkButton.set_visible(selectionMode)
if not selectionMode:
songWidget.model[songWidget._iter][6] = False
@log
def _check_button_toggled(self, button, songWidget):
if songWidget.model[songWidget._iter][6] != button.get_active():
songWidget.model[songWidget._iter][6] = button.get_active()
@log
def _model_row_changed(self, model, path, _iter):
if not self.selectionMode:
return
if not model[_iter][5]:
return
songWidget = model[_iter][5].song_widget
selected = model[_iter][6]
if model[_iter][11] == DiscoveryStatus.FAILED:
songWidget.now_playing_sign.set_from_icon_name(
ERROR_ICON_NAME, Gtk.IconSize.SMALL_TOOLBAR)
songWidget.now_playing_sign.show()
songWidget.can_be_played = False
if selected != songWidget.checkButton.get_active():
songWidget.checkButton.set_active(selected)
def _get_metadata(self, media=None):
if not media:
media = self.player.get_current_media()
if not media:
return {}
metadata = {
'mpris:trackid': self._get_media_id(media),
'xesam:url': media.get_url()
}
try:
length = dbus.Int64(media.get_duration() * 1000000)
assert length is not None
metadata['mpris:length'] = length
except:
pass
try:
trackNumber = media.get_track_number()
assert trackNumber is not None
metadata['xesam:trackNumber'] = trackNumber
except:
pass
try:
useCount = media.get_play_count()
assert useCount is not None
metadata['xesam:useCount'] = useCount
except:
pass
try:
userRating = media.get_rating()
assert userRating is not None
metadata['xesam:userRating'] = userRating
except:
pass
try:
title = AlbumArtCache.get_media_title(media)
assert title is not None
metadata['xesam:title'] = title
except:
pass
try:
album = media.get_album()
assert album is not None
except:
try:
album = media.get_string(Grl.METADATA_KEY_ALBUM)
assert album is not None
except:
album = _("Unknown Album")
finally:
metadata['xesam:album'] = album
try:
artist = media.get_artist()
assert artist is not None
except:
try:
artist = media.get_string(Grl.METADATA_KEY_ARTIST)
assert artist is not None
except:
try:
artist = media.get_author()
assert artist is not None
except (AssertionError, ValueError):
artist = _("Unknown Artist")
finally:
metadata['xesam:artist'] = [artist]
metadata['xesam:albumArtist'] = [artist]
try:
genre = media.get_genre()
assert genre is not None
metadata['xesam:genre'] = genre
except:
pass
try:
lastUsed = media.get_last_played()
assert lastUsed is not None
metadata['xesam:lastUsed'] = lastUsed
except:
pass
try:
artUrl = media.get_thumbnail()
assert artUrl is not None
metadata['mpris:artUrl'] = artUrl
except:
pass
return metadata
def _on_lookup_ready(self, icon, path, _iter):
if icon:
self._model.set_value(
_iter, 4,
albumArtCache.get_default()._make_icon_frame(icon))
def _get_metadata(self, media=None):
if not media:
media = self.player.get_current_media()
if not media:
return {}
metadata = {
'mpris:trackid': GLib.Variant('o', self._get_media_id(media)),
'xesam:url': GLib.Variant('s', media.get_url())
}
try:
length = media.get_duration() * 1000000
assert length is not None
metadata['mpris:length'] = GLib.Variant('x', length)
except:
pass
try:
trackNumber = media.get_track_number()
assert trackNumber is not None
metadata['xesam:trackNumber'] = GLib.Variant('i', trackNumber)
except:
pass
try:
useCount = media.get_play_count()
assert useCount is not None
metadata['xesam:useCount'] = GLib.Variant('i', useCount)
except:
pass
try:
userRating = media.get_rating()
assert userRating is not None
metadata['xesam:userRating'] = GLib.Variant('d', userRating)
except:
pass
try:
title = AlbumArtCache.get_media_title(media)
assert title is not None
metadata['xesam:title'] = GLib.Variant('s', title)
except:
pass
try:
album = media.get_album()
assert album is not None
except:
try:
album = media.get_album()
assert album is not None
except:
album = _("Unknown Album")
finally:
metadata['xesam:album'] = GLib.Variant('s', album)
try:
artist = media.get_artist()
assert artist is not None
except:
try:
artist = media.get_artist()
assert artist is not None
except:
try:
artist = media.get_artist()
assert artist is not None
except (AssertionError, ValueError):
artist = _("Unknown Artist")
finally:
metadata['xesam:artist'] = GLib.Variant('as', [artist])
metadata['xesam:albumArtist'] = GLib.Variant('as', [artist])
try:
genre = media.get_genre()
assert genre is not None
metadata['xesam:genre'] = GLib.Variant('as', genre)
except:
pass
try:
lastUsed = media.get_last_played()
assert lastUsed is not None
metadata['xesam:lastUsed'] = GLib.Variant('s', lastUsed)
except:
pass
try:
artUrl = media.get_thumbnail()
assert artUrl is not None
metadata['mpris:artUrl'] = GLib.Variant('s', artUrl)
except:
pass
return metadata
# modify this code, you may extend this exception to your version of the
# code, but you are not obligated to do so. If you do not wish to do so,
# delete this exception statement from your version.
from gi.repository import Gtk, Gdk, Gd, GLib, GObject, Pango, Gio
from gi.repository import GdkPixbuf, Grl
from gettext import gettext as _, ngettext
from gnomemusic.grilo import grilo
from gnomemusic.albumArtCache import AlbumArtCache
from gnomemusic.player import DiscoveryStatus
from gnomemusic.playlists import Playlists, StaticPlaylists
from gnomemusic import log
import logging
logger = logging.getLogger(__name__)
ALBUM_ART_CACHE = AlbumArtCache.get_default()
NOW_PLAYING_ICON_NAME = 'media-playback-start-symbolic'
ERROR_ICON_NAME = 'dialog-error-symbolic'
try:
settings = Gio.Settings.new('org.gnome.Music')
MAX_TITLE_WIDTH = settings.get_int('max-width-chars')
except Exception as e:
MAX_TITLE_WIDTH = 20
logger.error("Error on setting widget max-width-chars: %s", str(e))
playlists = Playlists.get_default()
class StarHandler():
def __repr__(self):
