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 __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 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 _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 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):