playlist.py

Go to the documentation of this file.

import gtk,gobject,pango,gtk.glade
import random,pickle

from plai.track import Track
from plai import config
from plai import popup
from plai import utility

_trackcol=4             # where to look for the track object in the treestore
                
class Playlist:
        """One of the playlists in tabs on the right of the window."""
        def __init__(self,widget):
                """Pass me with a gtk.ListView to be in."""
                self._view_view=widget
                self._store_store=gtk.ListStore(gobject.TYPE_STRING,     #artist
                                                                  gobject.TYPE_STRING,   #title
                                                                  gobject.TYPE_STRING,   #album
                                                                  gobject.TYPE_STRING,   #length (string so we can render it pretty)
                                                                  gobject.TYPE_PYOBJECT) #track
                self._view_view.set_model(self._store_store)
                self._view_view.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
                renderer=gtk.CellRendererText()
                renderer.set_property("ellipsize",pango.ELLIPSIZE_END)
                titles=['Artist','Title','Album','Length']
                for t in range(0,len(titles)):
                        column=gtk.TreeViewColumn(titles[t],renderer,text=t)
                        column.set_cell_data_func(renderer,self._FillAndHighlight_FillAndHighlight,0);
                        if t!=3: column.set_expand(True)
                        self._view_view.append_column(column)
                        
                self._curtrackref_curtrackref=None
                
                targets=[('foo',gtk.TARGET_SAME_APP,42)]
                self._view_view.enable_model_drag_dest(targets,gtk.gdk.ACTION_COPY|gtk.gdk.ACTION_MOVE)
                self._view_view.connect('drag-data-received',self._DragReceive_DragReceive)
                
                self._view_view.enable_model_drag_source(gtk.gdk.BUTTON1_MASK,targets,gtk.gdk.ACTION_MOVE)
                self._view_view.connect('drag-data-get',self._DragData_DragData)
                
                self._view_view.connect('button-press-event',self._onClick_onClick)
                                
                        
        def GetCurrentTrack(self):
                """Returns the current (highlighted) Track object if it
                exists, None otherwise."""
                if self._curtrackref_curtrackref==None or not self._curtrackref_curtrackref.valid(): return None
                return self._store_store.get_value(self._store_store.get_iter(self._curtrackref_curtrackref.get_path()),_trackcol)
                
                
        def SetCurrentTrack(self,it):
                """Sets the current track to the one pointed to by the gtk iterator 'it'.
                'it' may be None."""
                if self.GetCurrentTrackGetCurrentTrack(): self.GetCurrentTrackGetCurrentTrack().highlight=False
                
                if it==None: 
                        self._curtrackref_curtrackref=None
                else:
                        self._curtrackref_curtrackref=gtk.TreeRowReference(self._store_store,self._store_store.get_path(it))
                        self.GetCurrentTrackGetCurrentTrack().highlight=True
                self._Refresh_Refresh()
                
                
        def Shuffle(self):
                """Removes everything from the playlist and puts it back in a random order."""
                tracks=[]
                for row in self._store_store:
                        tracks.append(row[_trackcol])
                random.shuffle(tracks)
                self._view_view.set_model(None) #for speed
                self._store_store.clear()
                for t in tracks:
                        it=self._store_store.append()
                        self._store_store.set(it,_trackcol,t)
                self._view_view.set_model(self._store_store) #undo speed hack
                
                
        def _Refresh(self):
                """Forces a redraw (GTK doesn't always know we need one)."""
                self._view_view.queue_draw()
                
                
        def GotoNextTrack(self):
                """Moves onto the next track in the playlist if possible.
                Returns a boolean indicating success."""
                if self._curtrackref_curtrackref==None or not self._curtrackref_curtrackref.valid(): return False
                curit=self._store_store.get_iter(self._curtrackref_curtrackref.get_path())
                nextit=self._store_store.iter_next(curit)
                if nextit:
                        self.SetCurrentTrackSetCurrentTrack(nextit)
                        return True
                else:
                        return False
        
                
        def _FillAndHighlight(self,col,renderer,model,it,data):
                """Private, for use by the renderer to extract text from the Track object
                and draw the current track highlighted."""
                (track,)=model.get(it,_trackcol)
        
                coltitle=col.get_title()

                if coltitle=='Title':   renderer.set_property('text',track.Title())
                if coltitle=='Album':   renderer.set_property('text',track.Album())
                if coltitle=='Artist':  renderer.set_property('text',track.Artist())
                if coltitle=='Length':
                        l=track.Length()
                        txt=utility.PrettyPrintTime(l) if l!=-999 else ''
                        renderer.set_property('text',txt)

                if track.highlight:
                        renderer.set_property('foreground','red')                       
                        renderer.set_property('weight',800)                     
                else:
                        renderer.set_property('foreground',None)
                        renderer.set_property('weight',400)     
                        
                                        
        def ScrollToCurrent(self):
                """Scroll the playlist until the current track is 1/3 of the way down."""
                self._view_view.scroll_to_cell(self._curtrackref_curtrackref.get_path(),None,True,0.3)
#               """Do the minimum amount of scrolling to make the current track visible."""
#               self._view.scroll_to_cell(self._curtrackref.get_path()) #lazy scrolling
        
        
        def AppendTracks(self,tracks):  
                """Appends 'tracks' to the playlist. Returns an iterator to
                the first Track appended."""
                                
                retit=None
                #while this may well speed up the track appending, it makes it look less cool
                self._view_view.set_model(None) #for speed
                for t in tracks:
#                       while gtk.events_pending(): gtk.main_iteration() #try not to block the GUI
                        
                        it=self._store_store.append()
                        if retit==None: retit=it
                        self._store_store.set(it,_trackcol,t)
                self._view_view.set_model(self._store_store) #undo speed hack
                return retit
                
                
        def _DragReceive(self,widget,context,x,y,sel,info,time):
                """Callback for drag and drop. Expects drag data to be a pickled
                list of Track objects, as provided by CollectionTree.DragData()
                or by self.DragData()."""
                data=pickle.loads(sel.data)
                pathpos=widget.get_dest_row_at_pos(x,y)
                if pathpos:
                        (path,pos)=pathpos
                        it=self._store_store.get_iter(path)
                        if (pos==gtk.TREE_VIEW_DROP_BEFORE 
                         or pos==gtk.TREE_VIEW_DROP_INTO_OR_BEFORE):
                                firstit=self._store_store.insert_before(it)
                        else:
                                firstit=self._store_store.insert_after(it)
                else:
                        firstit=self._store_store.append()
                        
                self._store_store.set(firstit,_trackcol,data[0])
                nextit=firstit
                if len(data)>1:
                        for n in range(1,len(data)):
                                nextit=self._store_store.insert_after(nextit)
                                self._store_store.set(nextit,_trackcol,data[n])
                                
                if context.action==gtk.gdk.ACTION_MOVE:
                        context.finish(True,True,time)                  
        
                                
        def GetSelectedTracks(self):
                """Returns a list of Track objects representing the selected tracks."""
                (junk,paths)=self._view_view.get_selection().get_selected_rows()
                its=[self._store_store.get_iter(p) for p in paths]
                return [self._store_store.get_value(it,_trackcol) for it in its]
                
                
        def _DragData(self,widget,context,sel,info,time):
                """Callback for drag and drop. Provides a pickled list of Track objects."""
                sel.set(sel.target,8,pickle.dumps(self.GetSelectedTracksGetSelectedTracks(),pickle.HIGHEST_PROTOCOL))
                
        
        def GetState(self):
                """Returns a representation of the playlist's state.
                Form is currently ([tracks],currentpath)."""
                tracks=[row[_trackcol] for row in self._store_store]
                path=self._curtrackref_curtrackref.get_path() if self._curtrackref_curtrackref else None
                return (tracks,path)
                
                
        def SetState(self,state):
                """Initialises playlist to the state returned by GetState()."""
                (tracks,path)=state
                self.AppendTracksAppendTracks(tracks)
                if path:
                        self.SetCurrentTrackSetCurrentTrack(self._store_store.get_iter(path))
                        self.ScrollToCurrentScrollToCurrent()
                        
                self._view_view.set_sensitive(True)     # now fully initialised
        
        
        def RemoveSelected(self):
                """Removes the currently selected tracks from the playlist.
                Returns whether the currently playing track was removed."""
                wascurrent=False
                (junk,paths)=self._view_view.get_selection().get_selected_rows()
        # This assumes paths are in order.  Although it works there is no such
        # guarantee in Gtk+ API docs, so maybe a sort is necessary.
                paths.reverse()
                for (p,) in paths:
                        #TODO: find a neater way to test for this case
                        if self.GetCurrentTrackGetCurrentTrack() and (p,)==self._curtrackref_curtrackref.get_path():
                                wascurrent=True
                        self._store_store.remove(self._store_store.get_iter(p))
                        
                return wascurrent
                
                
        def _onClick(self,widget,event):
                """Handler for clicks on playlist. Responds to right-click by
                popping-up the context menu."""
                if event.button==3:
                        p=self._view_view.get_path_at_pos(int(event.x),int(event.y))
                        if p:
                                (path,col,x,y)=p
                                track=self._store_store.get_value(self._store_store.get_iter(path),_trackcol)
                                popup.ShowPopup(event,track)
                

---