Beispiel #1
0
 def load(self, track, play=True):
     """
         Stop current track, load track id and play it
         @param track as Track
         @param play as bool, ignored for radios
     """
     if track.id == Type.RADIOS:
         if not Lp().scanner.is_locked():
             Lp().window.pulse(False)
             Lp().window.pulse(True)
         RadioPlayer.load(self, track)
     else:
         if play:
             if track.is_web and\
                     not Gio.NetworkMonitor.get_default(
                                                  ).get_network_available():
                 self._current_track = track
                 self.set_next()
                 GLib.idle_add(self.next)
                 return
             # Do not update next if user clicked on a track
             if self.is_party and track != self._next_track:
                 self.__do_not_update_next = True
             BinPlayer.load(self, track)
         else:
             BinPlayer._load_track(self, track)
             self.emit('current-changed')
Beispiel #2
0
 def load(self, track, play=True):
     """
         Stop current track, load track id and play it
         @param track as Track
         @param play as bool, ignored for radios
     """
     if track.id == Type.RADIOS:
         if not Lp().scanner.is_locked():
             Lp().window.pulse(False)
             Lp().window.pulse(True)
         RadioPlayer.load(self, track)
     else:
         if play:
             if track.is_web and\
                     not Gio.NetworkMonitor.get_default(
                                                  ).get_network_available():
                 self._current_track = track
                 self.set_next()
                 GLib.idle_add(self.next)
                 return
             # Do not update next if user clicked on a track
             if self.is_party and track != self._next_track:
                 self.__do_not_update_next = True
             BinPlayer.load(self, track)
         else:
             BinPlayer._load_track(self, track)
             self.emit('current-changed')
Beispiel #3
0
 def load(self, track, play=True):
     """
         Stop current track, load track id and play it
         @param track as Track
         @param play as bool, ignored for radios
     """
     if track.id == Type.RADIOS:
         if not Lp().scanner.is_locked():
             Lp().window.pulse(False)
             Lp().window.pulse(True)
         RadioPlayer.load(self, track)
     else:
         if play:
             if track.is_youtube and\
                     not Gio.NetworkMonitor.get_default(
                                                  ).get_network_available():
                 Lp().notify.send(
                     _("No network available,"
                       " can't play this track"), track.uri)
                 # Force widgets to update (spinners)
                 self.emit('current-changed')
                 return
             # Do not update next if user clicked on a track
             if self.is_party and track != self._next_track:
                 self.__do_not_update_next = True
             BinPlayer.load(self, track)
         else:
             BinPlayer._load_track(self, track)
             self.emit('current-changed')
Beispiel #4
0
 def _on_bus_error(self, bus, message):
     """
         Pass error to Bin/Radio
         @param bus as Gst.Bus
         @param message as Gst.Message
     """
     BinPlayer._on_bus_error(self, bus, message)
     RadioPlayer._on_bus_error(self, bus, message)
Beispiel #5
0
 def __init__(self):
     BinPlayer.__init__(self)
     QueuePlayer.__init__(self)
     LinearPlayer.__init__(self)
     ShufflePlayer.__init__(self)
     UserPlaylistPlayer.__init__(self)
     RadioPlayer.__init__(self)
     ExternalsPlayer.__init__(self)
Beispiel #6
0
 def load(self, track):
     """
         Stop current track, load track id and play it
         @param track as Track
     """
     if track.id == Type.RADIOS:
         RadioPlayer.load(self, track)
     else:
         BinPlayer.load(self, track)
Beispiel #7
0
 def load(self, track):
     """
         Stop current track, load track id and play it
         @param track as Track
     """
     if track.id == Type.RADIOS:
         RadioPlayer.load(self, track)
     else:
         BinPlayer.load(self, track)
Beispiel #8
0
 def __init__(self):
     """
         Create all objects
     """
     BinPlayer.__init__(self)
     QueuePlayer.__init__(self)
     LinearPlayer.__init__(self)
     ShufflePlayer.__init__(self)
     UserPlaylistPlayer.__init__(self)
     RadioPlayer.__init__(self)
     ExternalsPlayer.__init__(self)
Beispiel #9
0
 def __init__(self):
     """
         Create all objects
     """
     BinPlayer.__init__(self)
     QueuePlayer.__init__(self)
     LinearPlayer.__init__(self)
     ShufflePlayer.__init__(self)
     UserPlaylistPlayer.__init__(self)
     RadioPlayer.__init__(self)
     ExternalsPlayer.__init__(self)
Beispiel #10
0
 def __init__(self):
     """
         Init player
     """
     BinPlayer.__init__(self)
     QueuePlayer.__init__(self)
     LinearPlayer.__init__(self)
     ShufflePlayer.__init__(self)
     UserPlaylistPlayer.__init__(self)
     RadioPlayer.__init__(self)
     ExternalsPlayer.__init__(self)
     self.update_crossfading()
Beispiel #11
0
 def __init__(self):
     """
         Init player
     """
     BinPlayer.__init__(self)
     QueuePlayer.__init__(self)
     LinearPlayer.__init__(self)
     ShufflePlayer.__init__(self)
     UserPlaylistPlayer.__init__(self)
     RadioPlayer.__init__(self)
     ExternalsPlayer.__init__(self)
     self.update_crossfading()
Beispiel #12
0
 def load(self, track, notify=True):
     """
         Stop current track, load track id and play it
         @param track as Track
         @param notify as bool
     """
     if track.id == Type.RADIOS:
         if not Lp().scanner.is_locked():
             Lp().window.pulse(False)
             Lp().window.pulse(True)
         RadioPlayer.load(self, track)
     else:
         BinPlayer.load(self, track, notify)
Beispiel #13
0
 def load(self, track, notify=True):
     """
         Stop current track, load track id and play it
         @param track as Track
         @param notify as bool
     """
     if track.id == Type.RADIOS:
         if not Lp().scanner.is_locked():
             Lp().window.pulse(False)
             Lp().window.pulse(True)
         RadioPlayer.load(self, track)
     else:
         BinPlayer.load(self, track, notify)
Beispiel #14
0
 def load(self, track, play=True):
     """
         Stop current track, load track id and play it
         @param track as Track
         @param play as bool, ignored for radios
     """
     if track.id == Type.RADIOS:
         RadioPlayer.load(self, track, play)
     else:
         if play:
             BinPlayer.load(self, track)
         else:
             BinPlayer._load_track(self, track)
             self.emit("current-changed")
Beispiel #15
0
 def __init__(self):
     """
         Init player
     """
     BinPlayer.__init__(self)
     QueuePlayer.__init__(self)
     LinearPlayer.__init__(self)
     ShufflePlayer.__init__(self)
     UserPlaylistPlayer.__init__(self)
     RadioPlayer.__init__(self)
     ExternalsPlayer.__init__(self)
     self.update_crossfading()
     self.__do_not_update_next = False
     Lp().settings.connect('changed::playback', self.__on_playback_changed)
Beispiel #16
0
 def __init__(self):
     """
         Init player
     """
     BinPlayer.__init__(self)
     QueuePlayer.__init__(self)
     LinearPlayer.__init__(self)
     ShufflePlayer.__init__(self)
     UserPlaylistPlayer.__init__(self)
     RadioPlayer.__init__(self)
     ExternalsPlayer.__init__(self)
     self.update_crossfading()
     self.__do_not_update_next = False
     Lp().settings.connect("changed::playback", self.__on_playback_changed)
Beispiel #17
0
 def __init__(self):
     """
         Init player
     """
     BinPlayer.__init__(self)
     QueuePlayer.__init__(self)
     LinearPlayer.__init__(self)
     ShufflePlayer.__init__(self)
     PlaylistPlayer.__init__(self)
     RadioPlayer.__init__(self)
     SimilarsPlayer.__init__(self)
     self.__stop_after_track_id = None
     self.update_crossfading()
     App().settings.connect("changed::repeat", self.__on_repeat_changed)
     self._albums_backup = []
Beispiel #18
0
    def set_next(self):
        """
            Play next track
            @param sql as sqlite cursor
        """
        # Look at externals
        self.next_track = ExternalsPlayer.next(self)

        # Look at radio
        if self.next_track.id is None:
            self.next_track = RadioPlayer.next(self)

        # Look first at user queue
        if self.next_track.id is None:
            self.next_track = QueuePlayer.next(self)
            if self.next_track.id is not None:
                self.context.next_track = LinearPlayer.next(self)

        # Look at user playlist then
        if self.next_track.id is None:
            self.next_track = UserPlaylistPlayer.next(self)

        # Get a random album/track then
        if self.next_track.id is None:
            self.next_track = ShufflePlayer.next(self)

        # Get a linear track then
        if self.next_track.id is None:
            if self.context.next_track is not None:
                self.next_track = self.context.next_track
                self.context.next_track = None
            else:
                self.next_track = LinearPlayer.next(self)
        self.emit('next-changed')
Beispiel #19
0
    def set_prev(self):
        """
            Set previous track
        """
        try:
            # Look at externals
            self._prev_track = ExternalsPlayer.prev(self)

            # Look at radio
            if self._prev_track.id is None:
                self._prev_track = RadioPlayer.prev(self)

            # Look at user playlist then
            if self._prev_track.id is None:
                self._prev_track = UserPlaylistPlayer.prev(self)

            # Look at shuffle
            if self._prev_track.id is None:
                self._prev_track = ShufflePlayer.prev(self)

            # Get a linear track then
            if self._prev_track.id is None:
                self._prev_track = LinearPlayer.prev(self)
            self.emit('prev-changed')
        except Exception as e:
            print("Player::set_prev", e)
Beispiel #20
0
    def set_prev(self):
        """
            Set previous track
        """
        try:
            # Look at externals
            self._prev_track = ExternalsPlayer.prev(self)

            # Look at radio
            if self._prev_track.id is None:
                self._prev_track = RadioPlayer.prev(self)

            # Look at user playlist then
            if self._prev_track.id is None:
                self._prev_track = UserPlaylistPlayer.prev(self)

            # Look at shuffle
            if self._prev_track.id is None:
                self._prev_track = ShufflePlayer.prev(self)

            # Get a linear track then
            if self._prev_track.id is None:
                self._prev_track = LinearPlayer.prev(self)
            self.emit('prev-changed')
        except Exception as e:
            print("Player::set_prev", e)
Beispiel #21
0
    def set_prev(self):
        """
            Set previous track
        """
        # Special case to return from queue
        if self._queue and self.context.prev_track.id is None:
            self.context.prev_track = self.current_track
        elif not self._queue and self.context.prev_track.id is not None:
            self.prev_track = self.context.prev_track
            self.context.prev_track = Track()
            self.emit('prev-changed')
            return

        # Look at externals
        self.prev_track = ExternalsPlayer.prev(self)

        # Look at radio
        if self.prev_track.id is None:
            self.prev_track = RadioPlayer.prev(self)

        # Look at user playlist then
        if self.prev_track.id is None:
            self.prev_track = UserPlaylistPlayer.prev(self)

        # Look at shuffle
        if self.prev_track.id is None:
            self.prev_track = ShufflePlayer.prev(self)

        # Get a linear track then
        if self.prev_track.id is None:
            self.prev_track = LinearPlayer.prev(self)
        self.emit('prev-changed')
Beispiel #22
0
    def set_prev(self):
        """
            Set previous track
        """
        try:
            if Lp().settings.get_enum('playback') == NextContext.REPEAT_TRACK:
                self._prev_track = self.current_track
            else:
                # Look at externals
                self._prev_track = ExternalsPlayer.prev(self)

            # Look at radio
            if self._prev_track.id is None:
                self._prev_track = RadioPlayer.prev(self)

            # Look at user playlist then
            if self._prev_track.id is None:
                self._prev_track = UserPlaylistPlayer.prev(self)

            # Look at shuffle
            if self._prev_track.id is None:
                self._prev_track = ShufflePlayer.prev(self)

            # Get a linear track then
            if self._prev_track.id is None:
                self._prev_track = LinearPlayer.prev(self)
            self.emit('prev-changed')
        except Exception as e:
            print("Player::set_prev", e)
Beispiel #23
0
    def set_next(self):
        """
            Play next track
            @param sql as sqlite cursor
        """
        # Reset finished context
        self._finished = NextContext.NONE

        # Look at externals
        self._next_track = ExternalsPlayer.next(self)

        # Look at radio
        if self._next_track.id is None:
            self._next_track = RadioPlayer.next(self)

        # Look first at user queue
        if self._next_track.id is None:
            self._next_track = QueuePlayer.next(self)

        # Look at user playlist then
        if self._next_track.id is None:
            self._next_track = UserPlaylistPlayer.next(self)

        # Get a random album/track then
        if self._next_track.id is None:
            self._next_track = ShufflePlayer.next(self)

        # Get a linear track then
        if self._next_track.id is None:
            self._next_track = LinearPlayer.next(self)

        self.emit('next-changed')
Beispiel #24
0
    def set_next(self):
        """
            Play next track
            @param sql as sqlite cursor
        """
        # Look at externals
        self.next_track = ExternalsPlayer.next(self)

        # Look at radio
        if self.next_track.id is None:
            self.next_track = RadioPlayer.next(self)

        # Look first at user queue
        if self.next_track.id is None:
            self.next_track = QueuePlayer.next(self)

        # Look at user playlist then
        if self.next_track.id is None:
            self.next_track = UserPlaylistPlayer.next(self)

        # Get a random album/track then
        if self.next_track.id is None:
            self.next_track = ShufflePlayer.next(self)

        # Get a linear track then
        if self.next_track.id is None:
            self.next_track = LinearPlayer.next(self)
Beispiel #25
0
    def set_prev(self):
        """
            Set previous track
        """
        # Special case to return from queue
        if self._queue and self.context.prev_track.id is None:
            self.context.prev_track = self.current_track
        elif not self._queue and self.context.prev_track.id is not None:
            self.prev_track = self.context.prev_track
            self.context.prev_track = Track()
            self.emit('prev-changed')
            return

        # Look at externals
        self.prev_track = ExternalsPlayer.prev(self)

        # Look at radio
        if self.prev_track.id is None:
            self.prev_track = RadioPlayer.prev(self)

        # Look at user playlist then
        if self.prev_track.id is None:
            self.prev_track = UserPlaylistPlayer.prev(self)

        # Look at shuffle
        if self.prev_track.id is None:
            self.prev_track = ShufflePlayer.prev(self)

        # Get a linear track then
        if self.prev_track.id is None:
            self.prev_track = LinearPlayer.prev(self)
        self.emit('prev-changed')
Beispiel #26
0
    def set_next(self):
        """
            Play next track
            @param sql as sqlite cursor
        """
        # Look at externals
        self.next_track = ExternalsPlayer.next(self)

        # Look at radio
        if self.next_track.id is None:
            self.next_track = RadioPlayer.next(self)

        # Look first at user queue
        if self.next_track.id is None:
            self.next_track = QueuePlayer.next(self)
            if self.next_track.id is not None:
                self.context.next_track = LinearPlayer.next(self)

        # Look at user playlist then
        if self.next_track.id is None:
            self.next_track = UserPlaylistPlayer.next(self)

        # Get a random album/track then
        if self.next_track.id is None:
            self.next_track = ShufflePlayer.next(self)

        # Get a linear track then
        if self.next_track.id is None:
            if self.context.next_track is not None:
                self.next_track = self.context.next_track
                self.context.next_track = None
            else:
                self.next_track = LinearPlayer.next(self)
        self.emit('next-changed')
Beispiel #27
0
    def set_next(self):
        """
            Play next track
            @param sql as sqlite cursor
        """
        # Look at externals
        self.next_track = ExternalsPlayer.next(self)

        # Look at radio
        if self.next_track.id is None:
            self.next_track = RadioPlayer.next(self)

        # Look first at user queue
        if self.next_track.id is None:
            self.next_track = QueuePlayer.next(self)

        # Look at user playlist then
        if self.next_track.id is None:
            self.next_track = UserPlaylistPlayer.next(self)

        # Get a random album/track then
        if self.next_track.id is None:
            self.next_track = ShufflePlayer.next(self)

        # Get a linear track then
        if self.next_track.id is None:
            self.next_track = LinearPlayer.next(self)
Beispiel #28
0
    def set_prev(self):
        """
            Set previous track
        """
        try:
            if Lp().settings.get_enum("playback") == NextContext.REPEAT_TRACK:
                self._prev_track = self._current_track
            else:
                # Look at externals
                self._prev_track = ExternalsPlayer.prev(self)

            # Look at radio
            if self._prev_track.id is None:
                self._prev_track = RadioPlayer.prev(self)

            # Look at user playlist then
            if self._prev_track.id is None:
                self._prev_track = UserPlaylistPlayer.prev(self)

            # Look at shuffle
            if self._prev_track.id is None:
                self._prev_track = ShufflePlayer.prev(self)

            # Get a linear track then
            if self._prev_track.id is None:
                self._prev_track = LinearPlayer.prev(self)
            self.emit("prev-changed")
        except Exception as e:
            print("Player::set_prev():", e)
Beispiel #29
0
 def load(self, track, play=True):
     """
         Stop current track, load track id and play it
         @param track as Track
         @param play as bool, ignored for radios
     """
     if track.id == Type.RADIOS:
         RadioPlayer.load(self, track)
     else:
         if play:
             # Do not update next if user clicked on a track
             if self.is_party and track != self._next_track:
                 self.__do_not_update_next = True
             BinPlayer.load(self, track)
         else:
             BinPlayer._load_track(self, track)
             self.emit("current-changed")
Beispiel #30
0
 def load(self, track, play=True):
     """
         Stop current track, load track id and play it
         @param track as Track
         @param play as bool, ignored for radios
     """
     if track.id == Type.RADIOS:
         if not Lp().scanner.is_locked():
             Lp().window.pulse(False)
             Lp().window.pulse(True)
         RadioPlayer.load(self, track)
     else:
         if play:
             BinPlayer.load(self, track)
         else:
             BinPlayer._load_track(self, track)
             self.emit('current-changed')
Beispiel #31
0
 def load(self, track, play=True):
     """
         Stop current track, load track id and play it
         @param track as Track
         @param play as bool, ignored for radios
     """
     if track.id == Type.RADIOS:
         if not Lp().scanner.is_locked():
             Lp().window.pulse(False)
             Lp().window.pulse(True)
         RadioPlayer.load(self, track)
     else:
         if play:
             BinPlayer.load(self, track)
         else:
             BinPlayer._load_track(self, track)
             self.emit('current-changed')
Beispiel #32
0
    def _set_prev(self):
        # Look at externals
        self.prev_track = ExternalsPlayer.prev(self)

        # Look at radio
        if self.prev_track.id is None:
            self.prev_track = RadioPlayer.prev(self)

        # Look at user playlist then
        if self.prev_track.id is None:
            self.prev_track = UserPlaylistPlayer.prev(self)

        # Look at shuffle
        if self.prev_track.id is None:
            self.prev_track = ShufflePlayer.prev(self)

        # Get a linear track then
        if self.prev_track.id is None:
            self.prev_track = LinearPlayer.prev(self)
Beispiel #33
0
    def set_next(self, force=False):
        """
            Play next track
            @param sql as sqlite cursor
            @param force as bool
        """
        try:
            # Reset finished context
            self._next_context = NextContext.NONE

            if Lp().settings.get_enum('playback') == NextContext.REPEAT_TRACK:
                next_track = self.current_track
            else:
                # Look at externals
                next_track = ExternalsPlayer.next(self)

            # Look at radio
            if next_track.id is None:
                next_track = RadioPlayer.next(self)

            # Look first at user queue
            if next_track.id is None:
                next_track = QueuePlayer.next(self)

            # Look at user playlist then
            if next_track.id is None:
                next_track = UserPlaylistPlayer.next(self, force)

            # Get a random album/track then
            if next_track.id is None:
                next_track = ShufflePlayer.next(self)

            # Get a linear track then
            if next_track.id is None:
                next_track = LinearPlayer.next(self)
            if next_track.is_web:
                self._load_web(next_track, False)
            self._next_track = next_track
            self.emit('next-changed')
        except Exception as e:
            print("Player::set_next", e)
Beispiel #34
0
    def set_next(self):
        """
            Play next track
            @param sql as sqlite cursor
        """
        # Reset finished context
        self._finished = NextContext.NONE

        # Special case to return from queue
        if self._queue and self.context.next_track.id is None:
            self.context.next_track = self.next_track
        elif not self._queue and self.context.next_track.id is not None:
            self.next_track = self.context.next_track
            self.context.next_track = Track()
            self.emit('next-changed')
            return

        # Look at externals
        self.next_track = ExternalsPlayer.next(self)

        # Look at radio
        if self.next_track.id is None:
            self.next_track = RadioPlayer.next(self)

        # Look first at user queue
        if self.next_track.id is None:
            self.next_track = QueuePlayer.next(self)

        # Look at user playlist then
        if self.next_track.id is None:
            self.next_track = UserPlaylistPlayer.next(self)

        # Get a random album/track then
        if self.next_track.id is None:
            self.next_track = ShufflePlayer.next(self)

        # Get a linear track then
        if self.next_track.id is None:
            self.next_track = LinearPlayer.next(self)

        self.emit('next-changed')
Beispiel #35
0
    def set_next(self, force=False):
        """
            Play next track
            @param sql as sqlite cursor
            @param force as bool
        """
        try:
            # Reset finished context
            self._next_context = NextContext.NONE

            if Lp().settings.get_enum('playback') == NextContext.REPEAT_TRACK:
                next_track = self._current_track
            else:
                # Look at externals
                next_track = ExternalsPlayer.next(self)

            # Look at radio
            if next_track.id is None:
                next_track = RadioPlayer.next(self)

            # Look first at user queue
            if next_track.id is None:
                next_track = QueuePlayer.next(self)

            # Look at user playlist then
            if next_track.id is None:
                next_track = UserPlaylistPlayer.next(self, force)

            # Get a random album/track then
            if next_track.id is None:
                next_track = ShufflePlayer.next(self)

            # Get a linear track then
            if next_track.id is None:
                next_track = LinearPlayer.next(self)
            if next_track.is_web:
                self._load_web(next_track, False)
            self._next_track = next_track
            self.emit('next-changed')
        except Exception as e:
            print("Player::set_next():", e)
Beispiel #36
0
    def set_prev(self):
        """
            Set previous track
        """
        # Look at externals
        self.prev_track = ExternalsPlayer.prev(self)

        # Look at radio
        if self.prev_track.id is None:
            self.prev_track = RadioPlayer.prev(self)

        # Look at user playlist then
        if self.prev_track.id is None:
            self.prev_track = UserPlaylistPlayer.prev(self)

        # Look at shuffle
        if self.prev_track.id is None:
            self.prev_track = ShufflePlayer.prev(self)

        # Get a linear track then
        if self.prev_track.id is None:
            self.prev_track = LinearPlayer.prev(self)
Beispiel #37
0
    def set_next(self, force=False):
        """
            Play next track
            @param sql as sqlite cursor
            @param force as bool
        """
        try:
            # Reset finished context
            self._finished = NextContext.NONE

            # Look at externals
            next_track = ExternalsPlayer.next(self)

            # Look at radio
            if next_track.id is None:
                next_track = RadioPlayer.next(self)

            # Look first at user queue
            if next_track.id is None:
                next_track = QueuePlayer.next(self)

            # Look at user playlist then
            if next_track.id is None:
                next_track = UserPlaylistPlayer.next(self, force)

            # Get a random album/track then
            if next_track.id is None:
                next_track = ShufflePlayer.next(self)

            # Get a linear track then
            if next_track.id is None:
                next_track = LinearPlayer.next(self)
            if next_track.is_youtube:
                self._load_youtube(next_track, False)
            self._next_track = next_track
            self.emit('next-changed')
        except Exception as e:
            print("Player::set_next", e)
Beispiel #38
0
    def set_prev(self):
        """
            Set previous track
        """
        # Look at externals
        self.prev_track = ExternalsPlayer.prev(self)

        # Look at radio
        if self.prev_track.id is None:
            self.prev_track = RadioPlayer.prev(self)

        # Look at user playlist then
        if self.prev_track.id is None:
            self.prev_track = UserPlaylistPlayer.prev(self)

        # Look at shuffle
        if self.prev_track.id is None:
            self.prev_track = ShufflePlayer.prev(self)

        # Get a linear track then
        if self.prev_track.id is None:
            self.prev_track = LinearPlayer.prev(self)
        self.emit('prev-changed')
Beispiel #39
0
 def load(self, track):
     if track.id == Type.RADIOS:
         RadioPlayer.load(self, track)
     else:
         BinPlayer.load(self, track)