player.py

Go to the documentation of this file.

from __future__ import with_statement

from plai.playlist import Playlist
from plai.utility import PrettyPrintTime, GreyedOut, ReportError
from plai.collectiontree import CollectionTree
from plai import config

import gtk,gobject,gst
import os,copy,pickle           
import gtk.glade

from plai import config 


class Player:
        """The main player. Handles the collection tree and playlists. Manages
        GUI not associated with these."""
        def __init__(self):
                xml=gtk.glade.XML(config.gladefname)
                handlers={'on_mainwindow_destroy'                                               : self._onQuit_onQuit,
                                  'on_SearchBox_changed'                                                : self._onSearch_onSearch,
                                  'on_SearchBox_activate'                                               : self._onSearch_onSearch,
                                  'on_SearchResults_row_activated'                              : self._onSearchActivate_onSearchActivate,
                                  'on_AddButton_clicked'                                                : self._onAdd_onAdd,
                                  'on_PauseButton_toggled'                                              : self._onPause_onPause,
                                  'on_RemoveButton_clicked'                                             : self._onRemove_onRemove,
                                  'on_VolumeSlider_value_changed'                               : self._onVolume_onVolume,
                                  'on_SongProgressEventBox_button_press_event'  : self._onSeek_onSeek,
                                  'on_ShuffleButton_clicked'                                    : self._onShuffle_onShuffle,
                                  'on_NewButton_clicked'                                                : self._onNew_onNew,
                                  'on_notebook_key_press_event'                                 : self._onNotebookKey_onNotebookKey}
                xml.signal_autoconnect(handlers)
                
                self._notebook_notebook=xml.get_widget('notebook')
                self._volslider_volslider=xml.get_widget('VolumeSlider')
                self._pausebutton_pausebutton=xml.get_widget('PauseButton')
                self._searchbox_searchbox=xml.get_widget('SearchBox')
                self._songprogress_songprogress=xml.get_widget('SongProgress')
                
                self._searchresults_searchresults=CollectionTree(xml.get_widget('SearchResults'))
                
                gobject.timeout_add(1000,self._onTimer_onTimer,None)    #TODO - turn this off when not needed, careful not to have more than one at once...
                
                self._playbin_playbin=gst.element_factory_make('playbin','myplayer')
                bus=self._playbin_playbin.get_bus()
                bus.add_watch(self._onBus_onBus,None)
                
                self._tonotify_tonotify=[]
                
                self._playingplaylist_playingplaylist=None
                
                self._lasttypingtime_lasttypingtime=0
                
                self._mainwin_mainwin=xml.get_widget('MainWindow')
                self._mainwin_mainwin.maximize()
                self._mainwin_mainwin.show()
                # The window won't be ready until SetState is finished
                self._mainwin_mainwin.set_sensitive(False)      
                
                
        def RegisterForNotifications(self,func):
                """Add a function to the list to call when the state changes."""
                self._tonotify_tonotify.append(func)
                
                
        def _SendNotification(self):
                """Private. Dispatch notifications. Call me whenever you change
                player state and think someone might be interested."""
                for f in self._tonotify_tonotify: f()
                
                
        def GetState(self):
                """Returns a representation of the player state suitable for giving
                to SetState() thus allowing persistance.
                Format is (currenttab,[(label,playliststate)],volume).
                TODO - make the bits that peek at private Playlist stuff be a function on Playlist."""
                if self._playingplaylist_playingplaylist:
                        curtab=self._notebook_notebook.page_num(self._playingplaylist_playingplaylist._view.get_data('Scroller'))
                else:
                        curtab=self._notebook_notebook.get_current_page()
                
                playlists=[]
                for n in range(self._notebook_notebook.get_n_pages()):          
                        page=self._notebook_notebook.get_nth_page(n)
                        label=self.GetPageLabelGetPageLabel(page).get_text()
                        pl=page.get_data('PlaylistObject')
                        plstate=pl.GetState()
                        playlists.append((label,plstate))
                        
                vol=self._volslider_volslider.get_value()
                
                return (curtab,playlists,vol)
                
                
        def SetState(self,state):
                """Sets the player state to that represented by 'state' as
                produced by GetState()."""
                
                def inittab(n):
                        page=self._notebook_notebook.get_nth_page(n)
                        pl=page.get_data('PlaylistObject')
                        (label,plstate)=playlists[n]
                        pl.SetState(plstate)
                        
                (curtab,playlists,vol)=state
                self._volslider_volslider.set_value(vol)
                
                for pl in playlists:
                        self._onNew_onNew(None)
                        (label,plstate)=pl
                        page=self._notebook_notebook.get_nth_page(self._notebook_notebook.get_current_page())
                        self.GetPageLabelGetPageLabel(page).set_text(label)
                        # The playlist is not fully constructed yet. Grey it out.
                        # This will be undone when SetState is called.
                        page.get_data('PlaylistObject')._view.set_sensitive(False)
                
                # We need to do this one now because the current track is required to
                # exist when we start playing below.
                inittab(curtab)
                # Initialise the rest of the tabs lazily: left to right.
                for n in range(len(playlists)):
                        if n!=curtab: gobject.idle_add(inittab,n)
                                        
                self._notebook_notebook.set_current_page(curtab)
                page=self._notebook_notebook.get_nth_page(self._notebook_notebook.get_current_page())
                self._playingplaylist_playingplaylist=page.get_data('PlaylistObject')
                self.StartPlayingStartPlaying()
                self.PausePause()
                
                self._mainwin_mainwin.set_sensitive(True)
                
        
        def GetPlayingPlaylist(self):
                """Returns the playlist containing the currently playing song."""
                return self._playingplaylist_playingplaylist            
                
                
        def GotoNextTrack(self):
                """Move to the next track in the current playlist and start playing it
                if possible. Otherwise pause the player."""
                if self.GetPlayingPlaylistGetPlayingPlaylist().GotoNextTrack():
                        self.GetPlayingPlaylistGetPlayingPlaylist().ScrollToCurrent()
                        self.StartPlayingStartPlaying()
                        self._SendNotification_SendNotification()
                else:
                        self.PausePause()
                
                
        def _onBus(self,bus,msg,data):
                """Callback. Handles messages from the gstreamer bus.
                Responds to EOS by proceeding to next track."""
                if msg.type==gst.MESSAGE_EOS:
                        self.GotoNextTrackGotoNextTrack()
                        return True
                elif msg.type==gst.MESSAGE_ERROR:
                        ReportError('GStreamer Error',msg.parse_error()[1])
                        
                        return True
                else:
                        #got some other message...
                        return True             
                
                
        def _onSearch(self,widget):
                """Private callback."""
#               with GreyedOut(widget):
                self.RefreshSearchRefreshSearch()
                

        def RefreshSearch(self):
                """Refreshes the search results tree using whatever
                   is in the search box."""
                self._searchresults_searchresults.RunQuery(self._searchbox_searchbox.get_text())
                                
                                
        def StartPlaying(self):
                """Starts playing the current track if it exists."""
                self._pausebutton_pausebutton.set_active(False)
                
                self._playbin_playbin.set_state(gst.STATE_NULL)
                if self._playingplaylist_playingplaylist.GetCurrentTrack():
                        self._playbin_playbin.set_property('uri','file://'+self._playingplaylist_playingplaylist.GetCurrentTrack().Filename())
                        self._playbin_playbin.set_state(gst.STATE_PLAYING)
                        
                self._SendNotification_SendNotification()
                
                
        def _onPlaylistActivate(self,widget,path,column):
                """Callback. Skips to the selected item in the current playlist."""
                it=widget.get_model().get_iter(path)
                self.GetCurrentPlaylistGetCurrentPlaylist().SetCurrentTrack(it)
                self._playingplaylist_playingplaylist=self.GetCurrentPlaylistGetCurrentPlaylist()
                self.StartPlayingStartPlaying()
                
                
        def _onSearchActivate(self,widget,path,column):
                """Callback. Appends selected search results to the current playlist
                and starts playing the first."""
                self.GetCurrentPlaylistGetCurrentPlaylist().SetCurrentTrack(self.AppendSearchSelectionToPlaylistAppendSearchSelectionToPlaylist())
                self.StartPlayingStartPlaying()
                

        def AppendSearchSelectionToPlaylist(self):
                """Appends the selected search results to the current playlist.
                Return an iterator to the first track appended."""
                tracks=self._searchresults_searchresults.GetSelectedTracks()
                tracks=[copy.copy(t) for t in tracks]
                return self.GetCurrentPlaylistGetCurrentPlaylist().AppendTracks(tracks)
                        
                        
        def _onAdd(self,widget):
                """Callback for Add button."""
                self.AppendSearchSelectionToPlaylistAppendSearchSelectionToPlaylist()           

        
        def Pause(self):
                """Pause the currently playing track."""
                self._playbin_playbin.set_state(gst.STATE_PAUSED)
                self._pausebutton_pausebutton.set_active(True)          
                
                self._SendNotification_SendNotification()
                
                
        def UnPause(self):
                """Resume the currently playing track."""
                self._playbin_playbin.set_state(gst.STATE_PLAYING)              
                self._pausebutton_pausebutton.set_active(False)
                
                self._SendNotification_SendNotification()
                
                
        def IsPaused(self):
                """Returns True if the current track is paused."""
                return self._pausebutton_pausebutton.get_active()
                
                
        def _onPause(self,widget):
                """Callback for the Pause button. Toggles whether the current song
                is paused based on what the button says."""
                if widget.get_active():
                        self.PausePause()
                else:
                        self.UnPauseUnPause()
                
                
        def _onVolume(self,widget):
                """Callback for the volume slider. Sets the gstreamer volume
                to what the slider says."""
                self._playbin_playbin.set_property('volume',.01*widget.get_value())


        def SaveState(self):
                """Writes out GetState() to 'config.picklefname'"""
                print 'Saving state',
                with file(config.picklefname,'w') as f:
                        pickle.dump(self.GetStateGetState(),f,pickle.HIGHEST_PROTOCOL)
                print ' - Done' 
                
        def _onQuit(self,widget):
                """Callback for the close button. Saves state and calls gtk.main_quit()."""
                self.PausePause()
                self.SaveStateSaveState()
                gtk.main_quit()
                
                
        def GetSongPosAndLength(self):
                """Returns the position in and length of the current track
                in seconds as a tuple."""
                try:
                        (pos,junk)=self._playbin_playbin.query_position(gst.FORMAT_TIME)
                        (length,junk)=self._playbin_playbin.query_duration(gst.FORMAT_TIME)
                        if pos<0: pos=0
                        if pos>length: pos=length
                        return (int(pos/1e9),int(length/1e9))
                except:
                        return (0,1)
                        
                
        def _onTimer(self,data):
                """Callback. Every second update the progress bar."""
                (pos,length)=self.GetSongPosAndLengthGetSongPosAndLength()
                        
                prog=self._songprogress_songprogress
                if(prog!=None):
                        prog.set_fraction(float(pos)/length)
                        prog.set_text(PrettyPrintTime(pos)+'/'+PrettyPrintTime(length))
                        
                self._SendNotification_SendNotification()
                
                return True             #we want more of these events
        
        
        def _onRemove(self,widget):
                """Callback for the Remove button. Removes the selected tracks
                from the current playlist."""
                wasplaying=self.GetCurrentPlaylistGetCurrentPlaylist().RemoveSelected()
                if wasplaying:
                        self._playbin_playbin.set_state(gst.STATE_NULL)
                        self.GetCurrentPlaylistGetCurrentPlaylist().SetCurrentTrack(None)
        
        
        def _onSeek(self,widget,event):
                """Callback for clicking on the song progress bar. Seeks to 
                the position in the stream that the user clicked."""
                (x,y)=widget.window.get_size()
                prog=float(event.x)/x;
                (length,junk)=self._playbin_playbin.query_duration(gst.FORMAT_TIME)
                length=length/1e9
                self._playbin_playbin.seek(1.0,gst.FORMAT_TIME,gst.SEEK_FLAG_FLUSH,gst.SEEK_TYPE_SET,prog*length*gst.SECOND,gst.SEEK_TYPE_NONE,0)                       
                self._songprogress_songprogress.set_fraction(prog)

                
        def _onShuffle(self,widget):
                """Callback for the Shuffle button. Shuffle the current playlist."""
                self.GetCurrentPlaylistGetCurrentPlaylist().Shuffle()
                
        
        def GetCurrentTrack(self):
                """Returns the current track or None if there isn't one."""
                pl=self.GetPlayingPlaylistGetPlayingPlaylist()
                return pl.GetCurrentTrack() if pl else None
                
        
        def _onNew(self,widget):
                """Callback for the New button. Adds a new notebook page,
                and adds the playlist object as data on the page."""
                xml=gtk.glade.XML(config.gladeplaylistfname)
                handlers={'on_Playlist_row_activated' : self._onPlaylistActivate_onPlaylistActivate,
                                  'on_Close_clicked'              : self._onCloseTab_onCloseTab}
                xml.signal_autoconnect(handlers)
                num=self._notebook_notebook.append_page(xml.get_widget('PlaylistScroller'),             
                                                                                xml.get_widget('PlaylistTitle'))
                xml.get_widget('Playlist').set_data('Scroller',xml.get_widget('PlaylistScroller'))                                                                              
                pl=Playlist(xml.get_widget('Playlist'))
                xml.get_widget('Close').set_data('ControlledTab',xml.get_widget('PlaylistScroller'))
                self._notebook_notebook.get_nth_page(num).set_data('PlaylistObject',pl)
                self._notebook_notebook.set_current_page(-1)
                
                
        def GetCurrentPlaylist(self):
                """Returns the Playlist object associated with the currently focussed tab."""
                page=self._notebook_notebook.get_nth_page(self._notebook_notebook.get_current_page())
                return page.get_data('PlaylistObject') if page else None
                
                
        def _onCloseTab(self,widget):
                """Callback for notebook page close buttons.
                Removes the tab in whose title 'widget' is."""
                tab=widget.get_data('ControlledTab')
                
                # Stop playing the current song if it lived in this tab. Otherwise
                # confusion might ensue.
                if self._playingplaylist_playingplaylist is tab.get_data('PlaylistObject'):
                        self._playbin_playbin.set_state(gst.STATE_NULL)
                
                self._notebook_notebook.remove_page(self._notebook_notebook.page_num(tab))
        
        
        def GetPageLabel(self,page):
                """Returns the gtk.Label for 'page' or None."""
                return self._notebook_notebook.get_tab_label(page).get_children()[0] if page else None
                
                
        def _onNotebookKey(self,widget,event):
                """Private callback for typing in the notebook. Modified the current
                page's title."""
                if event.string=='': return
                label=self.GetPageLabelGetPageLabel(self._notebook_notebook.get_nth_page(self._notebook_notebook.get_current_page()))
                if label:
                        if event.time-self._lasttypingtime_lasttypingtime>config.notebooktitletimeout:
                                label.set_text('')
                        self._lasttypingtime_lasttypingtime=event.time
                        label.set_text(label.get_text()+event.string)
                

---