# Copyright (C) 2008-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. import logging from typing import Dict, Union from gi.repository import Gtk from gi.repository import Gdk from gi.repository import GdkPixbuf from gi.repository import GObject from xl import common, event, radio, settings, trax from xl.nls import gettext as _ from xl.playlist import Playlist, SmartPlaylist from xlgui import icons, panel from xlgui.panel import menus from xlgui.widgets import dialogs from xlgui.widgets.common import DragTreeView from xlgui.widgets.smart_playlist_editor import SmartPlaylistEditor logger = logging.getLogger(__name__) class TrackWrapper: def __init__(self, track, playlist): self.track = track self.playlist = playlist def __str__(self): text = self.track.get_tag_raw('title') if text is not None: text = ' / '.join(text) if text: artists = self.track.get_tag_raw('artist') if artists: text += ' - ' + ' / '.join(artists) return text return self.track.get_loc_for_io() class BasePlaylistPanelMixin(GObject.Object): """ Base playlist tree object. Used by the radio and playlists panels to display playlists """ # HACK: Notice that this is not __gsignals__; descendants need to manually # merge this in. This is because new PyGObject doesn't like __gsignals__ # coming from mixin. See: # * https://bugs.launchpad.net/bugs/714484 # * http://www.daa.com.au/pipermail/pygtk/2011-February/019394.html _gsignals_ = { 'playlist-selected': (GObject.SignalFlags.RUN_LAST, None, (object,)), 'tracks-selected': (GObject.SignalFlags.RUN_LAST, None, (object,)), 'append-items': (GObject.SignalFlags.RUN_LAST, None, (object, bool)), 'replace-items': (GObject.SignalFlags.RUN_LAST, None, (object,)), 'queue-items': (GObject.SignalFlags.RUN_LAST, None, (object,)), } # Cache for custom playlists playlist_nodes: Dict[Playlist, Gtk.TreeIter] # Mapping to keep track of open "are you sure you want to delete" dialogs deletion_dialogs: Dict[Union[Playlist, SmartPlaylist], Gtk.Dialog] def __init__(self): """ Initializes the mixin """ GObject.Object.__init__(self) self.playlist_nodes = {} self.track_image = icons.MANAGER.pixbuf_from_icon_name( 'audio-x-generic', Gtk.IconSize.SMALL_TOOLBAR ) self.deletion_dialogs = {} def remove_playlist(self, ignored=None): """ Removes the selected playlist from the UI and from the underlying manager """ selected_playlist = self.tree.get_selected_page(raw=True) if selected_playlist is None: return dialog = self.deletion_dialogs.get(selected_playlist) if dialog: dialog.present() return def on_response(dialog, response): if response == Gtk.ResponseType.YES: if isinstance(selected_playlist, SmartPlaylist): self.smart_manager.remove_playlist(selected_playlist.name) else: self.playlist_manager.remove_playlist(selected_playlist.name) # Remove from {playlist: iter} cache. del self.playlist_nodes[selected_playlist] # Remove from UI. selection = self.tree.get_selection() (model, iter) = selection.get_selected() self.model.remove(iter) del self.deletion_dialogs[selected_playlist] dialog.destroy() dialog = Gtk.MessageDialog( buttons=Gtk.ButtonsType.YES_NO, message_type=Gtk.MessageType.QUESTION, text=_('Delete the playlist "%s"?') % selected_playlist.name, transient_for=self.parent, ) dialog.connect('response', on_response) self.deletion_dialogs[selected_playlist] = dialog dialog.present() def rename_playlist(self, playlist): """ Renames the playlist """ if playlist is None: return # Ask for new name dialog = dialogs.TextEntryDialog( _("Enter the new name you want for your playlist"), _("Rename Playlist"), playlist.name, parent=self.parent, ) result = dialog.run() name = dialog.get_value() dialog.destroy() if result != Gtk.ResponseType.OK or name == '': return if name in self.playlist_manager.playlists: # name is already in use dialogs.error( self.parent, _("The playlist name you entered is already in use.") ) return selection = self.tree.get_selection() (model, iter) = selection.get_selected() model.set_value(iter, 1, name) # Update the manager as well self.playlist_manager.rename_playlist(playlist, name) def open_selected_playlist(self): selection = self.tree.get_selection() (model, iter) = selection.get_selected() self.open_item(self.tree, model.get_path(iter), None) def on_rating_changed(self, widget, rating): """ Updates the rating of the selected tracks """ tracks = self.get_selected_tracks() for track in tracks: track.set_rating(rating) maximum = settings.get_option('rating/maximum', 5) event.log_event('rating_changed', self, 100 * rating / maximum) def open_item(self, tree, path, col): """ Called when the user double clicks on a playlist, also called when the user double clicks on a track beneath a playlist. When they active a track it opens the playlist and starts playing that track """ iter = self.model.get_iter(path) item = self.model.get_value(iter, 2) if item is not None: if isinstance(item, (Playlist, SmartPlaylist)): # for smart playlists if hasattr(item, 'get_playlist'): try: item = item.get_playlist(self.collection) except Exception as e: logger.exception("Error loading smart playlist") dialogs.error( self.parent, _("Error loading smart playlist: %s") % str(e) ) return else: # Get an up to date copy item = self.playlist_manager.get_playlist(item.name) # item.set_is_custom(True) # self.controller.main.add_playlist(item) self.emit('playlist-selected', item) else: self.emit('append-items', [item.track], True) def add_new_playlist(self, tracks=[], name=None): """ Adds a new playlist to the list of playlists. If name is None or the name conflicts with an existing playlist, the user will be queried for a new name. Returns the name of the new playlist, or None if it was not added. """ if name: if name in self.playlist_manager.playlists: name = dialogs.ask_for_playlist_name( self.get_panel().get_toplevel(), self.playlist_manager, name ) else: if tracks: artists = [] composers = [] albums = [] for track in tracks: artist = track.get_tag_display('artist', artist_compilations=False) if artist is not None: artists += [artist] composer = track.get_tag_display( 'composer', artist_compilations=False ) if composer is not None: composers += composer album = track.get_tag_display('album') if album is not None: albums += album artists = list(set(artists))[:3] composers = list(set(composers))[:3] albums = list(set(albums))[:3] if len(artists) > 0: name = artists[0] if len(artists) > 2: # TRANSLATORS: Playlist title suggestion with more # than two values name = _('%(first)s, %(second)s and others') % { 'first': artists[0], 'second': artists[1], } elif len(artists) > 1: # TRANSLATORS: Playlist title suggestion with two values name = _('%(first)s and %(second)s') % { 'first': artists[0], 'second': artists[1], } elif len(composers) > 0: name = composers[0] if len(composers) > 2: # TRANSLATORS: Playlist title suggestion with more # than two values name = _('%(first)s, %(second)s and others') % { 'first': composers[0], 'second': composers[1], } elif len(composers) > 1: # TRANSLATORS: Playlist title suggestion with two values name = _('%(first)s and %(second)s') % { 'first': composers[0], 'second': composers[1], } elif len(albums) > 0: name = albums[0] if len(albums) > 2: # TRANSLATORS: Playlist title suggestion with more # than two values name = _('%(first)s, %(second)s and others') % { 'first': albums[0], 'second': albums[1], } elif len(albums) > 1: # TRANSLATORS: Playlist title suggestion with two values name = _('%(first)s and %(second)s') % { 'first': albums[0], 'second': albums[1], } else: name = '' name = dialogs.ask_for_playlist_name( self.get_panel().get_toplevel(), self.playlist_manager, name ) if name is not None: # Create the playlist from all of the tracks new_playlist = Playlist(name) new_playlist.extend(tracks) # We are adding a completely new playlist with tracks so we save it self.playlist_manager.save_playlist(new_playlist) return name def _load_playlist_nodes(self, playlist): """ Loads the playlist tracks into the node for the specified playlist """ if playlist not in self.playlist_nodes: return expanded = self.tree.row_expanded( self.model.get_path(self.playlist_nodes[playlist]) ) self._clear_node(self.playlist_nodes[playlist]) parent = self.playlist_nodes[playlist] for track in playlist: if not track: continue wrapper = TrackWrapper(track, playlist) row = (self.track_image, str(wrapper), wrapper) self.model.append(parent, row) if expanded: self.tree.expand_row( self.model.get_path(self.playlist_nodes[playlist]), False ) def remove_selected_track(self): """ Removes the selected track from its playlist and saves the playlist """ selection = self.tree.get_selection() (model, iter) = selection.get_selected() track = model.get_value(iter, 2) if isinstance(track, TrackWrapper): del track.playlist[track.playlist.index(track.track)] # Update the list self.model.remove(iter) # TODO do we save the playlist after this?? self.playlist_manager.save_playlist(track.playlist, overwrite=True) class PlaylistsPanel(panel.Panel, BasePlaylistPanelMixin): """ The playlists panel """ __gsignals__ = BasePlaylistPanelMixin._gsignals_ ui_info = ('playlists.ui', 'PlaylistsPanel') def __init__(self, parent, playlist_manager, smart_manager, collection, name): """ Initializes the playlists panel @param playlist_manager: The playlist manager """ panel.Panel.__init__(self, parent, name, _('Playlists')) BasePlaylistPanelMixin.__init__(self) self.playlist_manager = playlist_manager self.smart_manager = smart_manager self.collection = collection self.box = self.builder.get_object('PlaylistsPanel') self.playlist_name_info = 500 self.track_target = Gtk.TargetEntry.new("text/uri-list", 0, 0) self.playlist_target = Gtk.TargetEntry.new( "playlist_name", Gtk.TargetFlags.SAME_WIDGET, self.playlist_name_info ) self.deny_targets = [Gtk.TargetEntry.new('', 0, 0)] self.tree = PlaylistDragTreeView(self) self.tree.connect('row-activated', self.open_item) self.tree.set_headers_visible(False) self.tree.connect('drag-motion', self.drag_motion) self.tree.drag_source_set( Gdk.ModifierType.BUTTON1_MASK, [self.track_target, self.playlist_target], Gdk.DragAction.COPY | Gdk.DragAction.MOVE, ) self.scroll = Gtk.ScrolledWindow() self.scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self.scroll.add(self.tree) self.scroll.set_shadow_type(Gtk.ShadowType.IN) self.box.pack_start(self.scroll, True, True, 0) self.box.show_all() pb = Gtk.CellRendererPixbuf() cell = Gtk.CellRendererText() if settings.get_option('gui/ellipsize_text_in_panels', False): from gi.repository import Pango cell.set_property('ellipsize-set', True) cell.set_property('ellipsize', Pango.EllipsizeMode.END) col = Gtk.TreeViewColumn('Text') col.pack_start(pb, False) col.pack_start(cell, True) col.set_attributes(pb, pixbuf=0) col.set_attributes(cell, text=1) self.tree.append_column(col) self.model = Gtk.TreeStore(GdkPixbuf.Pixbuf, str, object) self.tree.set_model(self.model) # icons self.folder = icons.MANAGER.pixbuf_from_icon_name( 'folder', Gtk.IconSize.SMALL_TOOLBAR ) self.playlist_image = icons.MANAGER.pixbuf_from_icon_name( 'music-library', Gtk.IconSize.SMALL_TOOLBAR ) # menus self.playlist_menu = menus.PlaylistsPanelPlaylistMenu(self) self.smart_menu = menus.PlaylistsPanelPlaylistMenu(self) self.default_menu = menus.PlaylistPanelMenu(self) self.track_menu = menus.TrackPanelMenu(self) self._connect_events() self._load_playlists() @property def menu(self): """ Gets a menu for the selected item :return: xlgui.widgets.menu.Menu or None if do not have it """ model, it = self.tree.get_selection().get_selected() pl = model[it][2] return ( self.playlist_menu if isinstance(pl, Playlist) else ( self.smart_menu if isinstance(pl, SmartPlaylist) else ( self.track_menu if isinstance(pl, TrackWrapper) else self.default_menu ) ) ) def _connect_events(self): event.add_ui_callback(self.refresh_playlists, 'track_tags_changed') event.add_ui_callback( self._on_playlist_added, 'playlist_added', self.playlist_manager ) self.tree.connect('key-release-event', self.on_key_released) def _playlist_properties(self): pl = self.tree.get_selected_page(raw=True) if isinstance(pl, SmartPlaylist): self.edit_selected_smart_playlist() def refresh_playlists(self, type, track, tags): """ wrapper so that multiple events dont cause multiple reloads in quick succession """ if settings.get_option('gui/sync_on_tag_change', True) and tags & { 'title', 'artist', }: self._refresh_playlists() @common.glib_wait(500) def _refresh_playlists(self): """ Callback for when tags have changed and the playlists need refreshing. """ if settings.get_option('gui/sync_on_tag_change', True): for playlist in self.playlist_nodes: self._load_playlist_nodes(playlist) def _on_playlist_added(self, type, object, playlist_name): new_playlist = self.playlist_manager.get_playlist(playlist_name) for oldpl in self.playlist_nodes: if oldpl.name == playlist_name: # Name already exists if oldpl is not new_playlist: node = self.playlist_nodes[oldpl] # Replace the playlist object in {playlist: iter} cache. del self.playlist_nodes[oldpl] self.playlist_nodes[new_playlist] = node # Replace the playlist object in tree model. self.model[node][2] = new_playlist break else: # Name doesn't exist yet self.playlist_nodes[new_playlist] = self.model.append( self.custom, [self.playlist_image, playlist_name, new_playlist] ) self.tree.expand_row(self.model.get_path(self.custom), False) # Refresh the playlist subnodes. self._load_playlist_nodes(new_playlist) def _load_playlists(self): """ Loads the currently saved playlists """ self.smart = self.model.append(None, [self.folder, _("Smart Playlists"), None]) self.custom = self.model.append( None, [self.folder, _("Custom Playlists"), None] ) names = sorted(self.smart_manager.playlists) for name in names: self.model.append( self.smart, [self.playlist_image, name, self.smart_manager.get_playlist(name)], ) names = sorted(self.playlist_manager.playlists) for name in names: playlist = self.playlist_manager.get_playlist(name) self.playlist_nodes[playlist] = self.model.append( self.custom, [self.playlist_image, name, playlist] ) self._load_playlist_nodes(playlist) self.tree.expand_row(self.model.get_path(self.smart), False) self.tree.expand_row(self.model.get_path(self.custom), False) def import_playlist(self): """ Shows a dialog to ask the user to import a new playlist """ def _on_playlists_selected(dialog, playlists): for playlist in playlists: self.add_new_playlist(playlist, playlist.name) dialog = dialogs.PlaylistImportDialog(parent=self.parent) dialog.connect('playlists-selected', _on_playlists_selected) dialog.show() def add_smart_playlist(self): """ Shows a dialog for adding a new smart playlist """ pl = SmartPlaylistEditor.create( self.collection, self.smart_manager, self.parent ) if pl: self.model.append(self.smart, [self.playlist_image, pl.name, pl]) def edit_selected_smart_playlist(self): """ Shows a dialog for editing the currently selected smart playlist """ pl = self.tree.get_selected_page(raw=True) self.edit_smart_playlist(pl) def edit_smart_playlist(self, pl): """ Shows a dialog for editing a smart playlist """ pl = SmartPlaylistEditor.edit( pl, self.collection, self.smart_manager, self.parent ) if pl: selection = self.tree.get_selection() model, it = selection.get_selected() model.set_value(it, 1, pl.name) model.set_value(it, 2, pl) def drag_data_received(self, tv, context, x, y, selection, info, etime): """ Called when someone drags some thing onto the playlist panel """ if info == self.playlist_name_info: # We are being dragged a playlist so # we have to reorder them playlist_name = selection.get_text() drag_source = self.tree.get_selected_page() # verify names if drag_source is not None: if drag_source.name == playlist_name: drop_info = tv.get_dest_row_at_pos(x, y) drag_source_iter = self.playlist_nodes[drag_source] if drop_info: path, position = drop_info drop_target_iter = self.model.get_iter(path) drop_target = self.model.get_value(drop_target_iter, 2) if position == Gtk.TreeViewDropPosition.BEFORE: # Put the playlist before drop_target self.model.move_before(drag_source_iter, drop_target_iter) self.playlist_manager.move( playlist_name, drop_target.name, after=False ) else: # put the playlist after drop_target self.model.move_after(drag_source_iter, drop_target_iter) self.playlist_manager.move( playlist_name, drop_target.name, after=True ) # Even though we are doing a move we still don't # call the delete method because we take care # of it above by moving instead of inserting/deleting context.finish(True, False, etime) else: self._drag_data_received_uris(tv, context, x, y, selection, info, etime) def _drag_data_received_uris(self, tv, context, x, y, selection, info, etime): """ Called by drag_data_received when the user drags URIs onto us """ locs = list(selection.get_uris()) drop_info = tv.get_dest_row_at_pos(x, y) if drop_info: path, position = drop_info iter = self.model.get_iter(path) drop_target = self.model.get_value(iter, 2) # if the current item is a track, use the parent playlist insert_index = None if isinstance(drop_target, TrackWrapper): current_playlist = drop_target.playlist drop_target_index = current_playlist.index(drop_target.track) # Adjust insert position based on drop position if ( position == Gtk.TreeViewDropPosition.BEFORE or position == Gtk.TreeViewDropPosition.INTO_OR_BEFORE ): # By default adding tracks inserts it before so we do not # have to modify the insert index insert_index = drop_target_index else: # If we want to go after we have to append 1 insert_index = drop_target_index + 1 else: current_playlist = drop_target # Since the playlist do not have very good support for # duplicate tracks we have to perform some trickery # to make this work properly in all cases try: remove_track_index = current_playlist.index( self.tree.get_selected_track() ) except ValueError: remove_track_index = None if insert_index is not None and remove_track_index is not None: # Since remove_track_index will be removed before # the new track is inserted we have to offset the # insert index if insert_index > remove_track_index: insert_index = insert_index - 1 # Delete the track before adding the other one # so we do not get duplicates # right now the playlist does not support # duplicate tracks very well if context.get_selected_action() == Gdk.DragAction.MOVE: # On a move action the second True makes the # drag_data_delete function called context.finish(True, True, etime) else: context.finish(True, False, etime) # Add the tracks we found to the internal playlist # TODO: have it pass in existing tracks? (tracks, playlists) = self.tree.get_drag_data(locs) if insert_index is not None: current_playlist[insert_index:insert_index] = tracks else: current_playlist.extend(tracks) self._load_playlist_nodes(current_playlist) # Do we save in the case when a user drags a file onto a playlist # in the playlist panel? note that the playlist does not have to # be open for this to happen self.playlist_manager.save_playlist(current_playlist, overwrite=True) else: # If the user dragged files prompt for a new playlist name # else if they dragged a playlist add the playlist # We don't want the tracks in the playlists to be added to the # master tracks list so we pass in False (tracks, playlists) = self.tree.get_drag_data(locs, False) # First see if they dragged any playlist files for new_playlist in playlists: # We are adding a completely new playlist with tracks so # we save it. This will trigger playlist_added. self.playlist_manager.save_playlist(new_playlist, overwrite=True) # After processing playlist proceed to ask the user for the # name of the new playlist to add and add the tracks to it if len(tracks) > 0: self.add_new_playlist(tracks) def drag_data_delete(self, tv, context): """ Called after a drag data operation is complete and we want to delete the source data """ if Gdk.drag_drop_succeeded(context): self.remove_selected_track() def drag_get_data(self, tv, context, selection_data, info, time): """ Called when someone drags something from the playlist """ # TODO based on info determine what we set in selection_data if info == self.playlist_name_info: pl = self.tree.get_selected_page() if pl is not None: selection_data.set_text(pl.name, len(pl.name)) else: pl = self.tree.get_selected_page() if pl is not None: tracks = pl[:] else: tracks = self.tree.get_selected_tracks() if not tracks: return for track in tracks: DragTreeView.dragged_data[track.get_loc_for_io()] = track uris = trax.util.get_uris_from_tracks(tracks) selection_data.set_uris(uris) def drag_motion(self, tv, context, x, y, time): """ Sets the appropriate drag action based on what we are hovering over hovering over playlists causes the copy action to occur hovering over tracks within the same playlist causes the move action to occur hovering over tracks within different playlist causes the move action to occur Called on the destination widget """ # Reset any target to be default to moving tracks self.tree.enable_model_drag_dest([self.track_target], Gdk.DragAction.DEFAULT) # Determine where the drag is coming from dragging_playlist = False if tv == self.tree: selected_playlist = self.tree.get_selected_page() if selected_playlist is not None: dragging_playlist = True # Find out where they are dropping onto drop_info = tv.get_dest_row_at_pos(x, y) if drop_info: path, position = drop_info iter = self.model.get_iter(path) drop_target = self.model.get_value(iter, 2) if isinstance(drop_target, Playlist): if dragging_playlist: # If we drag onto we copy, if we drag between we move if ( position == Gtk.TreeViewDropPosition.INTO_OR_BEFORE or position == Gtk.TreeViewDropPosition.INTO_OR_AFTER ): Gdk.drag_status(context, Gdk.DragAction.COPY, time) else: Gdk.drag_status(context, Gdk.DragAction.MOVE, time) # Change target as well self.tree.enable_model_drag_dest( [self.playlist_target], Gdk.DragAction.DEFAULT ) else: Gdk.drag_status(context, Gdk.DragAction.COPY, time) elif isinstance(drop_target, TrackWrapper): # We are dragging onto another track # make it a move operation if we are only dragging # tracks within our widget # We do a copy if we are draggin from another playlist if Gtk.drag_get_source_widget(context) == tv and not dragging_playlist: Gdk.drag_status(context, Gdk.DragAction.MOVE, time) else: Gdk.drag_status(context, Gdk.DragAction.COPY, time) else: # Prevent drop operation by changing the targets self.tree.enable_model_drag_dest( self.deny_targets, Gdk.DragAction.DEFAULT ) return False return True else: # No drop info if dragging_playlist: Gdk.drag_status(context, Gdk.DragAction.MOVE, time) # Change target as well self.tree.enable_model_drag_dest( [self.playlist_target], Gdk.DragAction.DEFAULT ) return True return False def on_key_released(self, widget, event): """ Called when a key is released in the tree """ if event.keyval == Gdk.KEY_Menu: (mods, paths) = self.tree.get_selection().get_selected_rows() if paths and paths[0]: iter = self.model.get_iter(paths[0]) pl = self.model.get_value(iter, 2) # Based on what is selected determines what # menu we will show if isinstance(pl, Playlist): Gtk.Menu.popup( self.playlist_menu, None, None, None, None, 0, event.time ) elif isinstance(pl, SmartPlaylist): Gtk.Menu.popup( self.smart_menu, None, None, None, None, 0, event.time ) elif isinstance(pl, TrackWrapper): Gtk.Menu.popup( self.track_menu, None, None, None, None, 0, event.time ) else: Gtk.Menu.popup( self.default_menu, None, None, None, None, 0, event.time ) return True if event.keyval == Gdk.KEY_Left: (mods, paths) = self.tree.get_selection().get_selected_rows() if paths and paths[0]: self.tree.collapse_row(paths[0]) return True if event.keyval == Gdk.KEY_Right: (mods, paths) = self.tree.get_selection().get_selected_rows() if paths and paths[0]: self.tree.expand_row(paths[0], False) return True if event.keyval == Gdk.KEY_Delete: (mods, paths) = self.tree.get_selection().get_selected_rows() if paths and paths[0]: iter = self.model.get_iter(paths[0]) pl = self.model.get_value(iter, 2) # Based on what is selected determines what # menu we will show if isinstance(pl, (Playlist, SmartPlaylist)): self.remove_playlist(pl) elif isinstance(pl, TrackWrapper): self.remove_selected_track() return True return False def _clear_node(self, node): """ Clears a node of all children """ iter = self.model.iter_children(node) while True: if not iter: break self.model.remove(iter) iter = self.model.iter_children(node) class PlaylistDragTreeView(DragTreeView): """ Custom DragTreeView to retrieve data from playlists """ def __init__(self, container, receive=True, source=True): DragTreeView.__init__(self, container, receive, source) self.show_cover_drag_icon = False def get_selection_empty(self): '''Returns True if there are no selected items''' return self.get_selection().count_selected_rows() == 0 def get_selection_is_computed(self): """ Returns True if selection is a Smart Playlist """ item = self.get_selected_item(raw=True) return isinstance(item, SmartPlaylist) def get_selected_tracks(self): """ Used by the menu, just basically gets the selected playlist and returns the tracks in it """ playlist = self.get_selected_page() if playlist is not None: return [track for track in playlist] else: return [self.get_selected_track()] return None def get_selected_page(self, raw=False): """ Retrieves the currently selected playlist in the playlists panel. If a non-playlist is selected it returns None @return: the playlist """ item = self.get_selected_item(raw=raw) if isinstance(item, (Playlist, SmartPlaylist)): return item else: return None def get_selected_track(self): item = self.get_selected_item() if not item: return None if isinstance(item, TrackWrapper): return item.track else: return None def get_selected_item(self, raw=False): (model, iter) = self.get_selection().get_selected() if not iter: return None item = model.get_value(iter, 2) # for smart playlists if isinstance(item, SmartPlaylist): if raw: return item try: return item.get_playlist(self.container.collection) except Exception: return None if isinstance(item, radio.RadioItem): if raw: return item return item.get_playlist() elif isinstance(item, Playlist): return item elif isinstance(item, TrackWrapper): return item else: return None