# Copyright (C) 2010 Adam Olsen # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. # # # The developers of the Exaile media player hereby grant permission # for non-GPL compatible GStreamer and Exaile plugins to be used and # distributed together with GStreamer and Exaile. This permission is # above and beyond the permissions granted by the GPL license by which # Exaile is covered. If you 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 Gdk from gi.repository import GdkPixbuf from gi.repository import GLib from gi.repository import GObject from gi.repository import Gtk from gi.repository import Pango import logging import sys from xl.nls import gettext as _ from xl.playlist import Playlist, is_valid_playlist, import_playlist from xl import common, event, main, player, providers, settings, trax, xdg from xlgui.widgets.common import AutoScrollTreeView from xlgui.widgets.notebook import NotebookPage from xlgui.widgets import dialogs, menu, menuitems, playlist_columns from xlgui import guiutil, icons logger = logging.getLogger(__name__) def default_get_playlist_func(parent, context): return player.QUEUE.current_playlist class ModesMenuItem(menu.MenuItem): """ A menu item having a submenu containing entries for shuffle modes. Defaults to adjusting the currently-playing playlist. """ modetype = '' display_name = "" def __init__(self, name, after, get_playlist_func=default_get_playlist_func): menu.MenuItem.__init__(self, name, None, after) self.get_playlist_func = get_playlist_func def factory(self, menu, parent, context): item = Gtk.ImageMenuItem.new_with_mnemonic(self.display_name) image = Gtk.Image.new_from_icon_name( 'media-playlist-' + self.modetype, size=Gtk.IconSize.MENU ) item.set_image(image) submenu = self.create_mode_submenu(item) item.set_submenu(submenu) pl = self.get_playlist_func(parent, context) item.set_sensitive(pl is not None) return item def create_mode_submenu(self, parent_item): names = getattr(Playlist, "%s_modes" % self.modetype) displays = getattr(Playlist, "%s_mode_names" % self.modetype) items = [] previous = None for name, display in zip(names, displays): after = [previous] if previous else [] item = menu.radio_menu_item( name, after, display, '%s_modes' % self.modetype, self.mode_is_selected, self.on_mode_activated, ) items.append(item) if previous is None: items.append(menu.simple_separator("sep", [items[-1].name])) previous = items[-1].name m = menu.Menu(parent_item) for item in items: m.add_item(item) return m def mode_is_selected(self, name, parent, context): pl = self.get_playlist_func(parent, context) if pl is None: return False return getattr(pl, "%s_mode" % self.modetype) == name def on_mode_activated(self, widget, name, parent, context): pl = self.get_playlist_func(parent, context) if pl is None: return False setattr(pl, "%s_mode" % self.modetype, name) class ShuffleModesMenuItem(ModesMenuItem): modetype = 'shuffle' display_name = _("S_huffle") class RepeatModesMenuItem(ModesMenuItem): modetype = 'repeat' display_name = _("R_epeat") class DynamicModesMenuItem(ModesMenuItem): modetype = 'dynamic' display_name = _("_Dynamic") class RemoveCurrentMenuItem(menu.MenuItem): """ Allows for removing the currently playing track from the current playlist """ def __init__(self, after, get_playlist_func=default_get_playlist_func): menu.MenuItem.__init__(self, 'remove-current', None, after) self.get_playlist_func = get_playlist_func def factory(self, menu, parent, context): """ Sets up the menu item """ item = Gtk.ImageMenuItem.new_with_mnemonic( _('Remove _Current Track From Playlist') ) item.set_image(Gtk.Image.new_from_icon_name('list-remove', Gtk.IconSize.MENU)) item.connect('activate', self.on_activate, parent, context) if player.PLAYER.is_stopped(): item.set_sensitive(False) return item def on_activate(self, menuitem, parent, context): """ Removes the currently playing track from the current playlist """ playlist = self.get_playlist_func(parent, context) if playlist and playlist.current == player.PLAYER.current: del playlist[playlist.current_position] class RandomizeMenuItem(menu.MenuItem): """ A menu item which randomizes the full playlist or the current selection """ def __init__(self, after): menu.MenuItem.__init__(self, 'randomize', None, after) def factory(self, menu, parent, context): """ Sets up the menu item """ label = _('R_andomize Playlist') if not context['selection-empty']: label = _('R_andomize Selection') item = Gtk.MenuItem.new_with_mnemonic(label) item.connect('activate', self.on_activate, parent, context) return item def on_activate(self, menuitem, parent, context): """ Randomizes the playlist or the selection """ positions = [path[0] for path in context['selected-paths']] # Randomize the full playlist if only one track was selected positions = positions if len(positions) > 1 else [] # If you don't unselect before randomizing, a large number of selected will # kill performance parent.get_selection().unselect_all() with parent.handler_block(parent._cursor_changed): context['playlist'].randomize(positions) # do this in a function to avoid polluting the global namespace def __create_playlist_tab_context_menu(): smi = menu.simple_menu_item sep = menu.simple_separator items = [] items.append( smi( 'new-tab', [], _("_New Playlist"), 'tab-new', lambda w, n, o, c: o.tab.notebook.create_new_playlist(), ) ) items.append(sep('new-tab-sep', ['new-tab'])) items.append( smi( 'save', ['new-tab-sep'], _("_Save"), 'document-save', callback=lambda w, n, p, c: p.on_save(), condition_fn=lambda n, p, c: ( p.can_save() and main.exaile().playlists.has_playlist_name(p.playlist.name) ), ) ) items.append( smi( 'saveas', ['save'], _("Save _As"), 'document-save-as', callback=lambda w, n, p, c: p.on_saveas(), condition_fn=lambda n, p, c: p.can_saveas(), ) ) items.append( smi( 'rename', ['saveas'], _("_Rename"), None, callback=lambda w, n, p, c: p.tab.start_rename(), condition_fn=lambda n, p, c: p.tab.can_rename(), ) ) items.append( smi( 'clear', ['rename'], _("_Clear"), 'edit-clear-all', lambda w, n, o, c: o.playlist.clear(), ) ) items.append(sep('tab-close-sep', ['clear'])) def _get_pl_func(o, c): return o.playlist items.append( menuitems.ExportPlaylistMenuItem('export', ['tab-close-sep'], _get_pl_func) ) items.append( menuitems.ExportPlaylistFilesMenuItem('export-files', ['export'], _get_pl_func) ) items.append(sep('tab-export-sep', ['export'])) items.append( smi( 'tab-close', ['tab-export-sep'], _("Close _Tab"), 'window-close', lambda w, n, o, c: o.tab.close(), ) ) for item in items: providers.register('playlist-tab-context-menu', item) __create_playlist_tab_context_menu() class PlaylistContextMenu(menu.ProviderMenu): def __init__(self, page): """ :param page: The :class:`PlaylistPage` this menu is associated with. """ menu.ProviderMenu.__init__(self, 'playlist-context-menu', page) self.attach_to_widget(page, None) def get_context(self): context = common.LazyDict(self._parent) context['playlist'] = lambda name, parent: parent.playlist context['selection-empty'] = ( lambda name, parent: parent.get_selection_count() == 0 ) context['selected-paths'] = lambda name, parent: parent.get_selected_paths() context['selected-items'] = lambda name, parent: parent.get_selected_items() context['selected-tracks'] = lambda name, parent: parent.get_selected_tracks() context['selection-count'] = lambda name, parent: parent.get_selection_count() return context class SPATMenuItem(menu.MenuItem): """ Menu item allowing for toggling playback stop after the selected track (SPAT) """ def __init__(self, name, after): menu.MenuItem.__init__(self, name, None, after) def factory(self, menu, parent, context): """ Generates the menu item """ display_name = _('_Stop Playback After This Track') icon_name = 'media-playback-stop' if context['selected-items']: selection_position = context['selected-items'][0][0] if selection_position == parent.playlist.spat_position: display_name = _('_Continue Playback After This Track') icon_name = 'media-playback-start' menuitem = Gtk.ImageMenuItem.new_with_mnemonic(display_name) menuitem.set_image(Gtk.Image.new_from_icon_name(icon_name, Gtk.IconSize.MENU)) menuitem.connect('activate', self.on_menuitem_activate, parent, context) return menuitem def on_menuitem_activate(self, menuitem, parent, context): """ Toggles the SPAT state """ selection_position = context['selected-items'][0][0] if selection_position == parent.playlist.spat_position: parent.playlist.spat_position = -1 else: parent.playlist.spat_position = selection_position def __create_playlist_context_menu(): smi = menu.simple_menu_item sep = menu.simple_separator items = [] items.append(menuitems.EnqueueMenuItem('enqueue', [])) items.append(SPATMenuItem('toggle-spat', [items[-1].name])) def rating_get_tracks_func(menuobj, parent, context): return [row[1] for row in context['selected-items']] items.append(menuitems.RatingMenuItem('rating', [items[-1].name])) # TODO: custom playlist item here items.append(sep('sep1', [items[-1].name])) def remove_tracks_cb(widget, name, playlistpage, context): tracks = context['selected-items'] playlist = playlistpage.playlist # If it's all one block, just delete it in one chunk for # maximum speed. positions = [t[0] for t in tracks] if positions == list(range(positions[0], positions[0] + len(positions))): del playlist[positions[0] : positions[0] + len(positions)] else: for position, track in tracks[::-1]: del playlist[position] items.append( smi( 'remove', [items[-1].name], _("_Remove from Playlist"), 'list-remove', remove_tracks_cb, ) ) items.append(RandomizeMenuItem([items[-1].name])) def playlist_menu_condition(name, parent, context): """ Returns True if the containing notebook's tab bar is hidden """ scrolledwindow = parent.get_parent() page = scrolledwindow.get_parent() return not page.tab.notebook.get_show_tabs() items.append( smi( 'playlist-menu', [items[-1].name], _('Playlist'), submenu=menu.ProviderMenu('playlist-tab-context-menu', None), condition_fn=playlist_menu_condition, ) ) items.append(sep('sep2', [items[-1].name])) items.append( smi( 'properties', [items[-1].name], _("_Track Properties"), 'document-properties', lambda w, n, o, c: o.show_properties_dialog(), ) ) for item in items: providers.register('playlist-context-menu', item) __create_playlist_context_menu() class PlaylistPageBase(NotebookPage): """ Base class for playlist pages. Subclasses can indicate that they support the following operations: save: - Define a function called 'on_save' save as: - Define a function called 'on_saveas' """ menu_provider_name = 'playlist-tab-context-menu' def __init__(self, playlist, player): NotebookPage.__init__(self) self.player = player self.playlist = playlist self.play_pixbuf = icons.MANAGER.pixbuf_from_icon_name( 'media-playback-start', size=Gtk.IconSize.MENU ) self.pause_pixbuf = icons.MANAGER.pixbuf_from_icon_name( 'media-playback-pause', size=Gtk.IconSize.MENU ) event.add_ui_callback( self.on_playback_state_change, "playback_track_start", player, destroy_with=self, ) event.add_ui_callback( self.on_playback_state_change, "playback_track_end", player, destroy_with=self, ) event.add_ui_callback( self.on_playback_state_change, "playback_player_pause", player, destroy_with=self, ) event.add_ui_callback( self.on_playback_state_change, "playback_player_resume", player, destroy_with=self, ) def on_playback_state_change(self, typ, player, track): """ Sets the tab icon to reflect the playback status """ if player.queue.current_playlist != self.playlist: self.tab.set_icon(None) elif typ in ('playback_player_end', 'playback_track_end'): self.tab.set_icon(None) elif typ in ('playback_track_start', 'playback_player_resume'): self.tab.set_icon(self.play_pixbuf) elif typ == 'playback_player_pause': self.tab.set_icon(self.pause_pixbuf) def can_save(self): return hasattr(self, 'on_save') def can_saveas(self): return hasattr(self, 'on_saveas') class PlaylistPage(PlaylistPageBase): """ Displays a playlist and associated controls. """ def __init__(self, playlist, player): """ :param playlist: The :class:`xl.playlist.Playlist` to display in this page. :param player: The :class:`xl.player._base.ExailePlayer` that this page is associated with :param queue: """ PlaylistPageBase.__init__(self, playlist, player) NotebookPage.__init__(self) self.icon = None self.loading = None self.loading_timer = None uifile = xdg.get_data_path("ui", "playlist.ui") self.builder = guiutil.get_builder(uifile) playlist_page = self.builder.get_object("playlist_page") for child in playlist_page.get_children(): packing = playlist_page.query_child_packing(child) playlist_page.remove(child) self.add(child) self.set_child_packing(child, *packing) self.shuffle_button = self.builder.get_object("shuffle_button") self.repeat_button = self.builder.get_object("repeat_button") self.dynamic_button = self.builder.get_object("dynamic_button") self.search_entry = guiutil.SearchEntry(self.builder.get_object("search_entry")) self.builder.connect_signals(self) self.playlist_window = self.builder.get_object("playlist_window") self.playlist_utilities_bar = self.builder.get_object('playlist_utilities_bar') self.view = PlaylistView(playlist, player) self.view.set_search_entry(self.search_entry.entry) self.view.connect( 'start-interactive-search', lambda *a: self.search_entry.entry.grab_focus() ) self.playlist_window.add(self.view) event.add_ui_callback( self.on_mode_changed, 'playlist_shuffle_mode_changed', self.playlist, self.shuffle_button, destroy_with=self, ) event.add_ui_callback( self.on_mode_changed, 'playlist_repeat_mode_changed', self.playlist, self.repeat_button, destroy_with=self, ) event.add_ui_callback( self.on_mode_changed, 'playlist_dynamic_mode_changed', self.playlist, self.dynamic_button, destroy_with=self, ) event.add_ui_callback( self.on_dynamic_playlists_provider_changed, 'dynamic_playlists_provider_added', destroy_with=self, ) event.add_ui_callback( self.on_dynamic_playlists_provider_changed, 'dynamic_playlists_provider_removed', destroy_with=self, ) event.add_ui_callback(self.on_option_set, 'gui_option_set', destroy_with=self) self.on_mode_changed( None, None, self.playlist.shuffle_mode, self.shuffle_button ) self.on_mode_changed(None, None, self.playlist.repeat_mode, self.repeat_button) self.on_mode_changed( None, None, self.playlist.dynamic_mode, self.dynamic_button ) self.on_dynamic_playlists_provider_changed(None, None, None) self.on_option_set( 'gui_option_set', settings, 'gui/playlist_utilities_bar_visible' ) self.view.connect('button-press-event', self.on_view_button_press_event) self.view.model.connect('data-loading', self.on_data_loading) if self.view.model.data_loading: self.on_data_loading(None, True) self.show_all() ## NotebookPage API ## def focus(self): self.view.grab_focus() def get_page_name(self): return self.playlist.name def set_page_name(self, name): self.playlist.name = name self.name_changed() def get_search_entry(self): return self.search_entry ## End NotebookPage ## ## PlaylistPageBase API ## # TODO: These two probably shouldn't reach back to main.. def on_save(self): main.exaile().playlists.save_playlist(self.playlist, overwrite=True) def on_saveas(self): exaile = main.exaile() playlists = exaile.playlists name = dialogs.ask_for_playlist_name( exaile.gui.main.window, playlists, self.playlist.name ) if name is not None: self.set_page_name(name) playlists.save_playlist(self.playlist) ## End PlaylistPageBase API ## def on_shuffle_button_press_event(self, widget, event): self.__show_toggle_menu( Playlist.shuffle_modes, Playlist.shuffle_mode_names, self.on_shuffle_mode_set, 'shuffle_mode', widget, event, ) def on_shuffle_button_popup_menu(self, widget): self.__show_toggle_menu( Playlist.shuffle_modes, Playlist.shuffle_mode_names, self.on_shuffle_mode_set, 'shuffle_mode', widget, None, ) return True def on_repeat_button_press_event(self, widget, event): self.__show_toggle_menu( Playlist.repeat_modes, Playlist.repeat_mode_names, self.on_repeat_mode_set, 'repeat_mode', widget, event, ) def on_repeat_button_popup_menu(self, widget): self.__show_toggle_menu( Playlist.repeat_modes, Playlist.repeat_mode_names, self.on_repeat_mode_set, 'repeat_mode', widget, None, ) return True def on_dynamic_button_toggled(self, widget): if widget.get_active(): self.playlist.dynamic_mode = self.playlist.dynamic_modes[1] else: self.playlist.dynamic_mode = self.playlist.dynamic_modes[0] def on_search_entry_activate(self, entry): filter_string = entry.get_text() self.view.filter_tracks(filter_string or None) def __show_toggle_menu(self, names, display_names, callback, attr, widget, event): """ Display the menu on the shuffle/repeat toggle buttons :param names: The list of names of the menu entries :param display_names: The list of names to display on each menu entry. :param callback: The function to call when a menu item is activated. It will be passed the name of the activated item. :param attr: The attribute of self.playlist to look at to determine the currently-selected item. :param widget: The ToggleButton to display the menu on :param event: The gtk event that triggered the menu display """ widget.set_active(True) menu = Gtk.Menu() menu.connect('deactivate', self._mode_menu_set_toggle, widget, attr) prev = None mode = getattr(self.playlist, attr) for name, disp in zip(names, display_names): group = None if prev is None else prev.get_group() item = Gtk.RadioMenuItem.new_with_mnemonic(group, disp) if name == mode: item.set_active(True) item.connect('activate', callback, name) menu.append(item) if prev is None: menu.append(Gtk.SeparatorMenuItem()) prev = item menu.attach_to_widget(widget) menu.show_all() if event is not None: menu.popup( None, None, guiutil.position_menu, widget, event.button, event.time ) else: menu.popup(None, None, guiutil.position_menu, widget, 0, 0) menu.reposition() def _mode_menu_set_toggle(self, menu, button, name): mode = getattr(self.playlist, name) self.on_mode_changed(None, None, mode, button) def on_shuffle_mode_set(self, widget, mode): """ Callback for the Shuffle mode menu """ if widget.get_active(): self.playlist.shuffle_mode = mode def on_repeat_mode_set(self, widget, mode): """ Callback for the Repeat mode menu """ if widget.get_active(): self.playlist.repeat_mode = mode def on_mode_changed(self, evtype, playlist, mode, button): button.set_active(mode != 'disabled') def on_dynamic_playlists_provider_changed(self, evtype, manager, provider): """ Updates the dynamic button on provider changes """ providers_available = len(providers.get('dynamic_playlists')) > 0 sensitive = False tooltip_text = _('Requires plugins providing dynamic playlists') if providers_available: sensitive = True tooltip_text = _('Dynamically add similar tracks to the playlist') self.dynamic_button.set_sensitive(sensitive) self.dynamic_button.set_tooltip_text(tooltip_text) def on_option_set(self, evtype, settings, option): """ Handles option changes """ if option == 'gui/playlist_utilities_bar_visible': visible = settings.get_option(option, True) self.playlist_utilities_bar.set_visible(visible) self.playlist_utilities_bar.set_sensitive(visible) self.playlist_utilities_bar.set_no_show_all(not visible) def on_data_loading(self, model, loading): '''Called when tracks are being loaded into the model''' if loading: if self.loading is None and self.loading_timer is None: self.view.set_model(None) self.loading_timer = GLib.timeout_add(500, self.on_data_loading_timer) else: if self.loading_timer is not None: GLib.source_remove(self.loading_timer) self.loading_timer = None self.view.set_model(self.view.modelfilter) if self.loading is not None: guiutil.gtk_widget_replace(self.loading, self.playlist_window) self.loading.destroy() self.loading = None def on_data_loading_timer(self): if self.loading_timer is None: return self.loading_timer = None grid = Gtk.Grid() sp = Gtk.Spinner() sp.start() lbl = Gtk.Label.new(_('Loading')) grid.attach(sp, 0, 0, 1, 1) grid.attach(lbl, 1, 0, 1, 1) grid.set_halign(Gtk.Align.CENTER) grid.set_valign(Gtk.Align.CENTER) self.loading = grid guiutil.gtk_widget_replace(self.playlist_window, self.loading) self.loading.show_all() def on_view_button_press_event(self, view, e): """ Displays the tab context menu upon clicks in the contained view """ path = view.get_path_at_pos(int(e.x), int(e.y)) # We only need the tree path if present path = path[0] if path else None if ( not path and e.type == Gdk.EventType.BUTTON_PRESS and e.triggers_context_menu() ): self.tab_menu.popup(None, None, None, None, e.button, e.time) class PlaylistView(AutoScrollTreeView, providers.ProviderHandler): __gsignals__ = {} def __init__(self, playlist, player): AutoScrollTreeView.__init__(self) providers.ProviderHandler.__init__(self, 'playlist-columns') self.playlist = playlist self.player = player self._current_vertical_scroll = 0 self._insert_row = -1 self._insert_count = 0 self.menu = PlaylistContextMenu(self) self.header_menu = menu.ProviderMenu('playlist-columns-menu', self) self.header_menu.set_context_func(self.get_header_context) self.header_menu.attach_to_widget(self) self.dragging = False self.pending_event = None self.pending_edit_id = None # Timeout to ensure a double-click didn't occur self.pending_edit_data = None # (path, col) or None self.pending_edit_ok = False # Set to True by release or timeout self._insert_focusing = False self._hack_is_osx = sys.platform == 'darwin' self._hack_osx_control_mask = False # Set to true if you only want things to be copied here, not moved self.dragdrop_copyonly = False self.set_fixed_height_mode(True) # MASSIVE speedup - don't disable this! self.set_enable_search(True) self.selection = self.get_selection() self.selection.set_mode(Gtk.SelectionMode.MULTIPLE) self._filter_matcher = None self._sort_columns = list(common.BASE_SORT_TAGS) # Column sort order self._setup_models() self._setup_columns() self.columns_changed_id = self.connect( "columns-changed", self.on_columns_changed ) self.targets = [ Gtk.TargetEntry.new("exaile-index-list", Gtk.TargetFlags.SAME_APP, 0), Gtk.TargetEntry.new("text/uri-list", 0, 0), ] self.drag_source_set( Gdk.ModifierType.BUTTON1_MASK, self.targets, Gdk.DragAction.COPY | Gdk.DragAction.MOVE, ) self.drag_dest_set( Gtk.DestDefaults.ALL, self.targets, Gdk.DragAction.COPY | Gdk.DragAction.DEFAULT | Gdk.DragAction.MOVE, ) event.add_ui_callback(self.on_option_set, "gui_option_set", destroy_with=self) event.add_ui_callback( self.on_playback_start, "playback_track_start", self.player, destroy_with=self, ) event.add_ui_callback( self.on_playback_start, "playlist_track_next", self.player, destroy_with=self, ) self._cursor_changed = self.connect("cursor-changed", self.on_cursor_changed) self.connect("row-activated", self.on_row_activated) self.connect("key-press-event", self.on_key_press_event) self.connect("drag-begin", self.on_drag_begin) self.connect("drag-drop", self.on_drag_drop) self.connect("drag-data-get", self.on_drag_data_get) self.connect("drag-data-received", self.on_drag_data_received) self.connect("drag-data-delete", self.on_drag_data_delete) self.connect("drag-end", self.on_drag_end) self.connect("drag-motion", self.on_drag_motion) self.connect("size-allocate", self.on_size_allocate) def do_destroy(self): # if this isn't disconnected, then the columns are emptied out and # the user's settings are overwritten with an empty list self.disconnect(self.columns_changed_id) AutoScrollTreeView.do_destroy(self) def _refilter(self): with guiutil.without_model(self): self.modelfilter.refilter() def filter_tracks(self, filter_string): """ Only show tracks that match the filter. If filter is None, then clear any existing filters. The filter will search any currently enabled columns AND the default columns. """ if filter_string is None: self._filter_matcher = None self._refilter() else: # Merge default columns and currently enabled columns keyword_tags = set( playlist_columns.DEFAULT_COLUMNS + [c.name for c in self.get_columns()[1:]] ) self._filter_matcher = trax.TracksMatcher( filter_string, case_sensitive=False, keyword_tags=keyword_tags ) logger.debug( "Filtering playlist %r by %r.", self.playlist.name, filter_string ) self._refilter() logger.debug( "Filtering playlist %r by %r completed.", self.playlist.name, filter_string, ) def get_selection_count(self): """ Returns the number of items currently selected in the playlist. Prefer this to len(get_selected_tracks()) et al if you will discard the actual track list """ return self.get_selection().count_selected_rows() def get_selected_tracks(self): """ Returns a list of :class:`xl.trax.Track` which are currently selected in the playlist. """ return [x[1] for x in self.get_selected_items()] def get_selected_paths(self): """ Returns a list of pairs of treepaths which are currently selected in the playlist. The treepaths are returned for the base model, so they are indices that can be used with the playlist currently associated with this view. """ selection = self.get_selection() model, paths = selection.get_selected_rows() if isinstance(model, Gtk.TreeModelFilter): paths = [model.convert_path_to_child_path(path) for path in paths] return paths def get_selected_items(self): """ Returns a list of pairs of indices and :class:`xl.trax.Track` which are currently selected in the playlist. The indices can be used with the playlist currently associated with this view. """ selection = self.get_selection() model, paths = selection.get_selected_rows() try: if isinstance(model, Gtk.TreeModelFilter): tracks = [ ( model.convert_path_to_child_path(path)[0], model.get_value(model.get_iter(path), 0), ) for path in paths ] else: tracks = [ (path[0], model.get_value(model.get_iter(path), 0)) for path in paths ] except TypeError: # one of the paths was invalid return [] return tracks def get_sort_column(self): for col in self.get_columns(): if col.get_sort_indicator(): return col return None def get_sort_by(self): sortcol = self.get_sort_column() if sortcol: reverse = sortcol.get_sort_order() == Gtk.SortType.DESCENDING else: reverse = False return (self._sort_columns, reverse) def play_track_at(self, position, track): """ When called, this will begin playback of a track at a given position in the internal playlist """ self._play_track_at(position, track) def _play_track_at( self, position, track, on_activated=False, restart_if_playing=False ): '''Internal API''' if not settings.get_option('playlist/enqueue_by_default', False) or ( self.playlist is self.player.queue and on_activated ): # If track is already playing, then: # a) if restart_if_playing flag is set, restart the track # b) otherwise, pause/resume it instead of starting over if ( on_activated and not self.player.is_stopped() and self.player.queue.current_playlist is self.playlist and self.playlist.get_current_position() == position and not (restart_if_playing and self.player.is_playing()) ): self.player.toggle_pause() elif self.player.queue.is_play_enabled(): self.playlist.set_current_position(position) self.player.queue.set_current_playlist(self.playlist) self.player.queue.play(track=track) elif self.playlist is not self.player.queue: self.player.queue.append(track) def _setup_columns(self): columns = settings.get_option('gui/columns', playlist_columns.DEFAULT_COLUMNS) provider_names = [p.name for p in providers.get('playlist-columns')] columns = [name for name in columns if name in provider_names] if not columns: columns = playlist_columns.DEFAULT_COLUMNS self.model._set_columns(columns) font, ratio = self._compute_font() # create a fixed column for the playlist icon self._setup_fixed_column(ratio) for column in columns: playlist_column = providers.get_provider('playlist-columns', column)( self, self.player, font, ratio ) playlist_column.connect('clicked', self.on_column_clicked) if isinstance(playlist_column.cellrenderer, Gtk.CellRendererText): playlist_column.set_attributes( playlist_column.cellrenderer, sensitive=PlaylistModel.COL_SENSITIVE, weight=PlaylistModel.COL_WEIGHT, ) else: playlist_column.set_attributes( playlist_column.cellrenderer, sensitive=PlaylistModel.COL_SENSITIVE ) self.append_column(playlist_column) header = playlist_column.get_widget() header.show() header.get_ancestor(Gtk.Button).connect( 'button-press-event', self.on_header_button_press, playlist_column ) header.get_ancestor(Gtk.Button).connect( 'key-press-event', self.on_header_key_press_event, playlist_column ) def _compute_font(self): font = settings.get_option('gui/playlist_font', None) if font is not None: font = Pango.FontDescription(font) default_font = Gtk.Widget.get_default_style().font_desc if font is None: font = default_font def_font_sz = default_font.get_size() # how much has the font deviated from normal? ratio = font.get_size() / def_font_sz # small fonts can be problematic.. # -> TODO: perhaps default widths could be specified # in character widths instead? then we could # calculate it instead of using arbitrary widths if ratio < 1: ratio = ratio * 1.25 return font, ratio def _setup_fixed_column(self, ratio): sz = Gtk.icon_size_lookup(Gtk.IconSize.BUTTON)[1] sz = max(int(sz * ratio), 1) cell = Gtk.CellRendererPixbuf() cell.set_property('xalign', 0.0) col = Gtk.TreeViewColumn('') col.pack_start(cell, False) col.set_max_width(sz) col.set_attributes(cell, pixbuf=PlaylistModel.COL_PIXBUF) col.set_resizable(False) col.set_reorderable(False) col.set_clickable(False) col.set_sizing(Gtk.TreeViewColumnSizing.FIXED) self.append_column(col) def _on_resize_columns(self): for col in self.cols: col._setup_sizing() pass def _refresh_columns(self): selection = self.get_selection() if not selection: # The widget has been destroyed return with self.handler_block(self.columns_changed_id): columns = self.get_columns() for col in columns: self.remove_column(col) col.destroyed = True self._setup_columns() self.queue_draw() def _setup_models(self): self.model = PlaylistModel(self.playlist, [], self.player, self) self.__setup_model_hook = self.model.connect( 'data-loading', self._on_after_model_loading ) self.modelfilter = self.model.filter_new() self.modelfilter.set_visible_func(self._modelfilter_visible_func) self.set_model(self.modelfilter) def _on_after_model_loading(self, ar1, now_loading): """ This is necessary to ensure that row-insert is connected after the initial loading due to threaded PlaylistModel::_load_data_thread and playlists greater than 500 tracks """ if not now_loading: self.model.connect('row-inserted', self.on_row_inserted) self.model.disconnect(self.__setup_model_hook) def _modelfilter_visible_func(self, model, iter, data): if self._filter_matcher is not None: track = model.get_value(iter, 0) return self._filter_matcher.match(trax.SearchResultTrack(track)) return True def on_header_button_press( self, widget: Gtk.Widget, event: Gdk.EventButton, header_column: playlist_columns.Column, ): if event.triggers_context_menu(): self.set_selected_header(header_column) self.header_menu.popup_at_pointer(event) return True def on_header_key_press_event( self, widget: Gtk.Widget, event: Gdk.EventKey, header_column: playlist_columns.Column, ): if event.keyval == Gdk.KEY_Menu: # Open context menu for selecting visible columns self.set_selected_header(header_column) self.header_menu.popup_at_widget(widget, event) return True def get_header_context(self, dummy): context = {} context['trigger_column'] = self.selected_header return context def set_selected_header(self, header: playlist_columns.Column) -> None: self.selected_header = header def on_columns_changed(self, widget): columns = [c.name for c in self.get_columns()[1:]] if columns != settings.get_option('gui/columns', []): settings.set_option('gui/columns', columns) def on_column_clicked(self, column): if self.model.data_loading: return order = None for col in self.get_columns()[1:]: if col.name == column.name: order = column.get_sort_order() if order == Gtk.SortType.ASCENDING: order = Gtk.SortType.DESCENDING else: order = Gtk.SortType.ASCENDING col.set_sort_indicator(True) col.set_sort_order(order) self._sort_columns.insert(0, column.name) else: col.set_sort_indicator(False) col.set_sort_order(Gtk.SortType.DESCENDING) reverse = order == Gtk.SortType.DESCENDING # Uniquify the list of sort columns def unique_ordered(seq): seen = set() return [x for x in seq if x not in seen and not seen.add(x)] self._sort_columns = unique_ordered(self._sort_columns) # If you don't unselect before sorting, a large number of selected will # kill performance self.get_selection().unselect_all() with self.handler_block(self._cursor_changed): self.playlist.sort(self._sort_columns, reverse=reverse) def on_option_set(self, typ, obj, data): if data == "gui/columns" or data == 'gui/playlist_font': self._refresh_columns() def on_playback_start(self, type, player, track): if ( player.queue.current_playlist == self.playlist and player.current == self.playlist.current and settings.get_option('gui/ensure_visible', True) ): self.scroll_to_current() def scroll_to_current(self): position = self.playlist.current_position if position >= 0: model = self.get_model() # If it's a filter, then the position isn't actually the path if hasattr(model, 'convert_child_path_to_path'): path = model.convert_child_path_to_path(Gtk.TreePath((position,))) if path: self.scroll_to_cell(path) self.set_cursor(path) def on_cursor_changed(self, widget): context = common.LazyDict(self) context['selection-empty'] = ( lambda name, parent: parent.get_selection_count() == 0 ) context['selected-items'] = lambda name, parent: parent.get_selected_items() context['selected-tracks'] = lambda name, parent: parent.get_selected_tracks() context['selection-count'] = lambda name, parent: parent.get_selection_count() event.log_event('playlist_cursor_changed', self, context) def on_row_activated(self, *args): try: position, track = self.get_selected_items()[0] except IndexError: return # Call with restart_if_playing flag set to True, so that # currently-playing track will be restarted self._play_track_at(position, track, True, True) def on_row_inserted(self, model, path, iter): """ When something is inserted into the playlist, focus on it. If there are multiple things inserted, focus only on the first. """ if not self._insert_focusing: self._insert_focusing = True # HACK: GI: We get a segfault if we don't do this, because the # GtkTreePath gets deleted before the idle function is run. path = path.copy() def _set_cursor(): self.set_cursor(path) self._insert_focusing = False GLib.idle_add(_set_cursor) def do_button_press_event(self, e): """ Adds some custom selection work to 1) unselect all rows if clicking an empty area, 2) updating the selection upon right click and 3) popping up the context menu upon right click Also sets the internal state for button pressed Taken from the following sources: * thunar_details_view_button_press_event() of thunar-details-view.c * MultiDragTreeView.__button_press/__button.release of quodlibet/qltk/views.py """ # need this to workaround bug in GTK+ on OSX when dragging/dropping # -> https://bugzilla.gnome.org/show_bug.cgi?id=722815 if self._hack_is_osx: self._hack_osx_control_mask = ( True if e.state & Gdk.ModifierType.CONTROL_MASK else False ) selection = self.get_selection() pathtuple = self.get_path_at_pos(int(e.x), int(e.y)) # We only need the tree path if present if pathtuple: path = pathtuple[0] col = pathtuple[1] else: path = None # We unselect all selected items if the user clicks on an empty # area of the treeview and no modifier key is active if not e.state & Gtk.accelerator_get_default_mod_mask() and not path: selection.unselect_all() if path and e.type == Gdk.EventType.BUTTON_PRESS: # Prevent unselection of all except the clicked item on left # clicks, required to preserve the selection for DnD if ( e.button == Gdk.BUTTON_PRIMARY and not e.state & Gtk.accelerator_get_default_mod_mask() and selection.path_is_selected(path) ): if selection.count_selected_rows() > 1: selection.set_select_function(lambda *args: False, None) self.pending_event = (path, col) elif hasattr(col, 'could_edit') and col.could_edit(self, path, e): # TODO: should cache this? tm = self.get_settings().props.gtk_double_click_time if self.pending_edit_id: GLib.source_remove(self.pending_edit_id) self.pending_edit_data = (path, col) self.pending_edit_ok = False self.pending_edit_id = GLib.timeout_add( tm, self._editing_double_click_ok ) if e.triggers_context_menu(): # Select the path on which the user clicked if not selected yet if not selection.path_is_selected(path): # We don't unselect all other items if Control is active if not e.state & Gdk.ModifierType.CONTROL_MASK: selection.unselect_all() selection.select_path(path) self.menu.popup(None, None, None, None, e.button, e.time) return True elif e.type == Gdk.EventType.DOUBLE_BUTTON_PRESS: self._cancel_editing() return Gtk.TreeView.do_button_press_event(self, e) def do_button_release_event(self, e): """ Unsets the internal state for button press """ self._hack_osx_control_mask = False # Restore regular selection behavior in any case self.get_selection().set_select_function(lambda *args: True, None) if self.pending_event: path, col = self.pending_event # perform the normal selection that would have happened self.set_cursor(path, col, 0) self.pending_event = None self._maybe_start_editing() return Gtk.TreeView.do_button_release_event(self, e) def _cancel_editing(self): self.pending_edit_ok = False self.pending_edit_data = None if self.pending_edit_id: GLib.source_remove(self.pending_edit_id) self.pending_edit_id = None def _editing_double_click_ok(self): self.pending_edit_id = None self._maybe_start_editing() return False def _maybe_start_editing(self): # this has to be called twice for an edit to start # -> either by the double click timeout, or button release if self.pending_edit_ok: path, col = self.pending_edit_data col.start_editing(self, path) self.pending_edit_ok = False self.pending_edit_data = None elif self.pending_edit_data: self.pending_edit_ok = True def on_key_press_event(self, widget, event): if event.keyval == Gdk.KEY_Menu: self.menu.popup(None, None, None, None, 0, event.time) return True elif event.keyval == Gdk.KEY_Delete: indexes = [x[0] for x in self.get_selected_paths()] with guiutil.without_model(self): if indexes and indexes == list( range(indexes[0], indexes[0] + len(indexes)) ): del self.playlist[indexes[0] : indexes[0] + len(indexes)] else: for i in indexes[::-1]: del self.playlist[i] # TODO: localization? # -> Also, would be good to expose these shortcuts somehow to the user... # it seems that Gtk.BindingSet is the way to do it, but there isn't a # mechanism to enumerate it in python elif event.keyval == Gdk.KEY_q: if self.playlist is not self.player.queue: self.player.queue.extend(self.get_selected_tracks()) elif event.keyval == Gdk.KEY_Up and event.state & Gdk.ModifierType.MOD1_MASK: indexes = [x[0] for x in self.get_selected_paths()] if len(indexes) == 1 and indexes[0] != 0: idx = indexes[0] track = self.playlist.pop(idx) self.playlist[idx - 1 : idx - 1] = [track] elif event.keyval == Gdk.KEY_Down and event.state & Gdk.ModifierType.MOD1_MASK: indexes = [x[0] for x in self.get_selected_paths()] if len(indexes) == 1 and indexes[0] != len(self.playlist) - 1: idx = indexes[0] track = self.playlist.pop(idx) self.playlist[idx + 1 : idx + 1] = [track] elif event.keyval == Gdk.KEY_F2: path, column = self.get_cursor() if path and isinstance(column, playlist_columns.EditableColumn): column.start_editing(self, path) # Prevent space-key from triggering 'row-activated' signal, # which restarts the currently-playing track. Instead, we call # _play_track_at() here with restart_if_playing flag set to # False, so that pause will be always toggled instead. elif event.keyval == Gdk.KEY_space: try: position, track = self.get_selected_items()[0] except IndexError: return True # Prevent 'row-activated' self._play_track_at(position, track, True, False) return True # Prevent 'row-activated' # Columns with editable rows will take row-activated and start editing # but we want to start playback, so simulate it instead elif event.keyval == Gdk.KEY_Return: self.on_row_activated() return True # Prevent 'row-activated' ### DND handlers ### # Source def on_drag_begin(self, widget, context): """ Activates the dragging state """ # TODO: set drag icon self.dragging = True self.pending_event = None self._cancel_editing() self.get_selection().set_select_function(lambda *args: True, None) def on_drag_data_get(self, widget, context, selection, info, etime): """ Stores indices and URIs of the selected items in the drag selection """ target_atom = selection.get_target() target = target_atom.name() if target == "exaile-index-list": positions = self.get_selected_paths() if positions: s = ",".join(str(i[0]) for i in positions) selection.set(target_atom, 8, s.encode('utf-8')) elif target == "text/uri-list": tracks = self.get_selected_tracks() uris = trax.util.get_uris_from_tracks(tracks) selection.set_uris(uris) def on_drag_data_delete(self, widget, context): """ Stops the default handler from running, all processing occurs in the drag-data-received handler """ self.stop_emission_by_name('drag-data-delete') def on_drag_end(self, widget, context): """ Deactivates the dragging state """ self.dragging = False # Dest def on_drag_drop(self, widget, context, x, y, etime): """ Always allows processing of drop operations """ return True def on_drag_data_received(self, widget, context, x, y, selection, info, etime): """ Builds a list of tracks either from internal indices or external URIs and inserts or appends them to the playlist """ # Stop default handler from running self.stop_emission_by_name('drag-data-received') # Makes `self.on_row_inserted` to ignore inserted rows # see https://github.com/exaile/exaile/issues/487 self._insert_focusing = True drop_info = self.get_dest_row_at_pos(x, y) if drop_info: path, position = drop_info model = self.get_model() if isinstance(model, Gtk.TreeModelFilter): path = model.convert_path_to_child_path(path) insert_position = path[0] if position in ( Gtk.TreeViewDropPosition.AFTER, Gtk.TreeViewDropPosition.INTO_OR_AFTER, ): insert_position += 1 else: insert_position = -1 # hack: see https://github.com/exaile/exaile/issues/479 if self._hack_is_osx: source_widget = Gtk.drag_get_source_widget(context) if not (source_widget is None or source_widget is self) and hasattr( source_widget, 'get_selected_tracks' ): try: tracks = source_widget.get_selected_tracks() if insert_position >= 0: self.playlist[insert_position:insert_position] = tracks else: self.playlist.extend(tracks) insert_position = len(self.playlist) - len(tracks) except Exception: pass # Any exception on hack is ignored else: # Select inserted items if tracks: self.selection.unselect_all() self.selection.select_range( self.model.get_path( self.model.iter_nth_child(None, insert_position) ), self.model.get_path( self.model.iter_nth_child( None, insert_position + len(tracks) - 1 ) ), ) # Restore state to `self.on_row_inserted` do not ignore inserted rows # see https://github.com/exaile/exaile/issues/487 self._insert_focusing = False return tracks = [] playlist = [] positions = [] pos = 0 source_playlist_view = None target = selection.get_target().name() if target == "exaile-index-list": selection_data = selection.get_data().decode('utf-8') if selection_data == '': # Ignore drops from empty areas # Restore state to `self.on_row_inserted` do not ignore inserted rows # see https://github.com/exaile/exaile/issues/487 self._insert_focusing = False return positions = [int(pos) for pos in selection_data.split(",")] tracks = common.MetadataList() source_playlist_view = Gtk.drag_get_source_widget(context) playlist = self.playlist # Get the playlist of the if source_playlist_view is not self: playlist = source_playlist_view.playlist current_position_index = -1 for i, pos in enumerate(positions): if pos == playlist.current_position: current_position_index = i tracks.append(playlist[pos]) # Insert at specific position if possible if insert_position >= 0: self.playlist[insert_position:insert_position] = tracks if source_playlist_view is self: # Update position for tracks after the insert position for i, position in enumerate(positions[:]): if position >= insert_position: position += len(tracks) positions[i] = position # Update playlist current position if current_position_index >= 0: self.playlist.current_position = ( insert_position + current_position_index ) self.model.update_row_params(self.playlist.current_position) else: # Otherwise just append the tracks self.playlist.extend(tracks) insert_position = len(self.playlist) - len(tracks) elif target == "text/uri-list": uris = selection.get_uris() tracks = [] for uri in uris: if is_valid_playlist(uri): tracks.extend(import_playlist(uri)) else: tracks.extend(trax.get_tracks_from_uri(uri)) sort_by, reverse = self.get_sort_by() tracks = trax.sort_tracks( sort_by, tracks, reverse=reverse, artist_compilations=True ) if insert_position >= 0: self.playlist[insert_position:insert_position] = tracks else: self.playlist.extend(tracks) insert_position = len(self.playlist) - len(tracks) # Remove tracks from the source playlist if moved if context.get_selected_action() == Gdk.DragAction.MOVE: for i in positions[::-1]: del playlist[i] delete = context.get_selected_action() == Gdk.DragAction.MOVE context.finish(True, delete, etime) scroll_when_appending_tracks = settings.get_option( 'gui/scroll_when_appending_tracks', False ) if scroll_when_appending_tracks and tracks: self.scroll_to_cell(self.playlist.index(tracks[-1])) elif 0 < len(tracks) <= 500: # Keep insert position and length of selection for restoring after updating the playlist view if ( 0 < pos < insert_position and source_playlist_view is self and context.get_selected_action() == Gdk.DragAction.MOVE ): insert_position -= len(tracks) self._insert_row = insert_position self._insert_count = len(tracks) # Restore state to `self.on_row_inserted` do not ignore inserted rows # see https://github.com/exaile/exaile/issues/487 self._insert_focusing = False def on_drag_motion(self, widget, context, x, y, etime): """ Makes sure tracks can only be inserted before or after tracks and sets the drop action to move or copy depending on target and user interaction (e.g. Ctrl key) """ drop_info = self.get_dest_row_at_pos(x, y) if not drop_info: return False path, position = drop_info if position == Gtk.TreeViewDropPosition.INTO_OR_BEFORE: position = Gtk.TreeViewDropPosition.BEFORE elif position == Gtk.TreeViewDropPosition.INTO_OR_AFTER: position = Gtk.TreeViewDropPosition.AFTER self.set_drag_dest_row(path, position) action = Gdk.DragAction.MOVE _, _, _, modifier = self.get_window().get_pointer() target = self.drag_dest_find_target(context, None).name() if ( target == 'text/uri-list' or (self._hack_is_osx and self._hack_osx_control_mask) or (not self._hack_is_osx and modifier & Gdk.ModifierType.CONTROL_MASK) ): action = Gdk.DragAction.COPY if self.dragdrop_copyonly and Gtk.drag_get_source_widget(context) != self: action = Gdk.DragAction.COPY Gdk.drag_status(context, action, etime) return True def on_size_allocate(self, plView, selection): if self._insert_row > -1: # correction of selected rows self.select_rows( self._insert_row, self._insert_row + self._insert_count - 1 ) self._insert_row = -1 self._insert_count = 0 def show_properties_dialog(self): from xlgui import properties items = self.get_selected_items() # If only one track is selected, we expand `tracks` to include all # tracks in the playlist... except for really large playlists, this # essentially hangs. Instead, only show all tracks *if* the playlist # size is less than 100. # # A better option would be to lazy load the files, but I'm too lazy # to implement that now.. :) if len(items) == 1 and len(self.playlist) < 100: tracks = self.playlist[:] current_position = items[0][0] else: tracks = [i[1] for i in items] current_position = 0 properties.TrackPropertiesDialog(self.get_toplevel(), tracks, current_position) def on_provider_removed(self, provider): """ Called when a column provider is removed """ columns = settings.get_option('gui/columns') if provider.name in columns: columns.remove(provider.name) settings.set_option('gui/columns', columns) def select_rows(self, start, stop): self.selection.unselect_all() if self.model.iter_nth_child(None, start) == None: return if self.model.iter_nth_child(None, stop) == None: return self.selection.select_range( self.model.get_path(self.model.iter_nth_child(None, start)), self.model.get_path(self.model.iter_nth_child(None, stop)), ) class PlaylistModel(Gtk.ListStore): """ This ListStore contains all the information needed to render a playlist via a PlaylistView. There are five columns: * xl.trax.Track * dictionary (tag cache) * Gdk.Pixbuf (indicates whether track is playing or not) * boolean (indicates whether row is sensitive) * Pango.Weight (indicates if row is the playing track or not) The cache keys correspond to the tags rendered by each column. When a track changes, the row's corresponding cache is cleared and the row change event is fired. The cache keys are populated by the playlist columns. This arrangement ensures that we don't have to recreate the playlist model each time the columns are changed. """ __gsignals__ = { # Called with true indicates starting operation, False ends op 'data-loading': (GObject.SignalFlags.RUN_LAST, None, (GObject.TYPE_BOOLEAN,)) } COL_TRACK = 0 COL_CACHE = 1 COL_PIXBUF = 2 COL_SENSITIVE = 3 COL_WEIGHT = 4 PARAM_COLS = (COL_PIXBUF, COL_SENSITIVE, COL_WEIGHT) def __init__(self, playlist, column_names, player, parent): # columns: Track, Pixbuf, dict (cache) Gtk.ListStore.__init__( self, object, object, GdkPixbuf.Pixbuf, bool, Pango.Weight ) self.playlist = playlist self.player = player self._set_columns(column_names) self.data_loading = False self.data_load_queue = [] self._redraw_timer = None self._redraw_queue = [] event.add_ui_callback( self.on_tracks_added, "playlist_tracks_added", playlist, destroy_with=parent ) event.add_ui_callback( self.on_tracks_removed, "playlist_tracks_removed", playlist, destroy_with=parent, ) event.add_ui_callback( self.on_current_position_changed, "playlist_current_position_changed", playlist, destroy_with=parent, ) event.add_ui_callback( self.on_spat_position_changed, "playlist_spat_position_changed", playlist, destroy_with=parent, ) event.add_ui_callback( self.on_playback_state_change, "playback_track_start", self.player, destroy_with=parent, ) event.add_ui_callback( self.on_playback_state_change, "playback_track_end", self.player, destroy_with=parent, ) event.add_ui_callback( self.on_playback_state_change, "playback_player_pause", self.player, destroy_with=parent, ) event.add_ui_callback( self.on_playback_state_change, "playback_player_resume", self.player, destroy_with=parent, ) event.add_ui_callback( self.on_track_tags_changed, "track_tags_changed", destroy_with=parent ) event.add_ui_callback(self.on_option_set, "gui_option_set", destroy_with=parent) self._setup_icons() self.on_tracks_added( None, self.playlist, list(enumerate(self.playlist)) ) # populate the list def _set_columns(self, column_names): self.column_names = set(column_names) def _setup_icons(self): self.play_pixbuf = icons.ExtendedPixbuf( icons.MANAGER.pixbuf_from_icon_name('media-playback-start') ) self.pause_pixbuf = icons.ExtendedPixbuf( icons.MANAGER.pixbuf_from_icon_name('media-playback-pause') ) self.stop_pixbuf = icons.ExtendedPixbuf( icons.MANAGER.pixbuf_from_icon_name('media-playback-stop') ) stop_overlay_pixbuf = self.stop_pixbuf.scale_simple( dest_width=self.stop_pixbuf.pixbuf.get_width() // 2, dest_height=self.stop_pixbuf.pixbuf.get_height() // 2, interp_type=GdkPixbuf.InterpType.BILINEAR, ) stop_overlay_pixbuf = stop_overlay_pixbuf.move( offset_x=stop_overlay_pixbuf.pixbuf.get_width(), offset_y=stop_overlay_pixbuf.pixbuf.get_height(), resize=True, ) self.play_stop_pixbuf = self.play_pixbuf & stop_overlay_pixbuf self.pause_stop_pixbuf = self.pause_pixbuf & stop_overlay_pixbuf self.clear_pixbuf = self.play_pixbuf.copy() self.clear_pixbuf.pixbuf.fill(0x00000000) font = settings.get_option('gui/playlist_font', None) if font is not None: # get default font default = float(Gtk.Widget.get_default_style().font_desc.get_size()) new_font = Pango.FontDescription.from_string(font).get_size() # scale pixbuf accordingly t = GdkPixbuf.InterpType.BILINEAR s = max(int(self.play_pixbuf.get_width() * (new_font / default)), 1) self.play_pixbuf = self.play_pixbuf.scale_simple(s, s, t) self.pause_pixbuf = self.pause_pixbuf.scale_simple(s, s, t) self.stop_pixbuf = self.stop_pixbuf.scale_simple(s, s, t) self.play_stop_pixbuf = self.play_stop_pixbuf.scale_simple(s, s, t) self.pause_stop_pixbuf = self.pause_stop_pixbuf.scale_simple(s, s, t) self.clear_pixbuf = self.clear_pixbuf.scale_simple(s, s, t) def _refresh_icons(self): self._setup_icons() itr = self.get_iter_first() position = 0 while itr: self.set(itr, self.PARAM_COLS, self._compute_row_params(position)) itr = self.iter_next(itr) position += 1 def on_option_set(self, typ, obj, data): if data == "gui/playlist_font": self._refresh_icons() def _compute_row_params(self, rowidx): """ :returns: pixbuf, sensitive, weight """ pixbuf = self.clear_pixbuf.pixbuf weight = Pango.Weight.NORMAL sensitive = True playlist = self.playlist spatpos = playlist.spat_position spat = spatpos == rowidx if spat: pixbuf = self.stop_pixbuf.pixbuf if playlist is self.player.queue.current_playlist: if ( playlist.current_position == rowidx and playlist[rowidx] == self.player.current ): # this row is the current track, set a special icon state = self.player.get_state() weight = Pango.Weight.HEAVY if state == 'playing': if spat: pixbuf = self.play_stop_pixbuf.pixbuf else: pixbuf = self.play_pixbuf.pixbuf elif state == 'paused': if spat: pixbuf = self.pause_stop_pixbuf.pixbuf else: pixbuf = self.pause_pixbuf.pixbuf if spatpos == -1 or spatpos > rowidx: sensitive = True else: sensitive = False return pixbuf, sensitive, weight def update_row_params(self, position): itr = self.iter_nth_child(None, position) if itr is not None: self.set(itr, self.PARAM_COLS, self._compute_row_params(position)) ### Event callbacks to keep the model in sync with the playlist ### def on_tracks_added(self, event_type, playlist, tracks): self._load_data(tracks) def on_tracks_removed(self, event_type, playlist, tracks): for position, track in reversed(tracks): if position < 0: continue self.remove(self.iter_nth_child(None, position)) def on_current_position_changed(self, event_type, playlist, positions): for position in positions: if position < 0: continue self.update_row_params(position) def on_spat_position_changed(self, event_type, playlist, positions): pos = min(positions) if pos < 0: pos = 0 itr = self.get_iter_first() else: itr = self.iter_nth_child(None, pos) while itr: self.set(itr, self.PARAM_COLS, self._compute_row_params(pos)) itr = self.iter_next(itr) pos += 1 def on_playback_state_change(self, event_type, player_obj, track): position = self.playlist.current_position if position < 0 or position >= len(self): return self.update_row_params(position) def on_track_tags_changed(self, type, track, tags): if ( not track or not settings.get_option('gui/sync_on_tag_change', True) or not (tags & self.column_names) ): return if self._redraw_timer: GLib.source_remove(self._redraw_timer) self._redraw_queue.append(track) self._redraw_timer = GLib.timeout_add(100, self._on_track_tags_changed) def _on_track_tags_changed(self): self._redraw_timer = None redraw_queue = set(self._redraw_queue) self._redraw_queue = [] COL_TRACK = self.COL_TRACK COL_CACHE = self.COL_CACHE for row in self: if row[COL_TRACK] in redraw_queue: row[COL_CACHE].clear() self.row_changed(row.path, row.iter) # # Loading data into the playlist: # # - Profiler reveals that most of the playlist loading time is spent in two # places # - Formatting values # - Converting them to GValue objects for insert into the treeview # # Now, the program is annoyingly blocked when this happens, so we need to # process new tracks on a different thread, and show some kind of loading # indicator instead. That's what these four functions help us do. # def _load_data(self, tracks): # Don't allow race condition between adds.. there's probably a race # condition for removal if self.data_loading: self.data_load_queue.extend(tracks) return self.data_loading = True self.emit('data-loading', True) if len(tracks) > 500: self._load_data_thread(tracks) else: render_data = self._load_data_fn(tracks) self._load_data_done(render_data) @common.threaded def _load_data_thread(self, tracks): render_data = self._load_data_fn(tracks) GLib.idle_add(self._load_data_done, render_data) def _load_data_fn(self, tracks): indices = (0, 1, 2, 3, 4) return [ (position, indices, (track, {}) + self._compute_row_params(position)) for position, track in tracks ] def _load_data_done(self, render_data): for args in render_data: self.insert_with_valuesv(*args) self.data_loading = False self.emit('data-loading', False) if self.data_load_queue: tracks = self.data_load_queue self.data_load_queue = [] self._load_data(tracks)