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')
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')
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')
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)
def __init__(self):
BinPlayer.__init__(self)
QueuePlayer.__init__(self)
LinearPlayer.__init__(self)
ShufflePlayer.__init__(self)
UserPlaylistPlayer.__init__(self)
RadioPlayer.__init__(self)
ExternalsPlayer.__init__(self)
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)
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)
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)
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)
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()
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()
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)
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)
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")
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)
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)
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 = []
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')
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)
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)
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')
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)
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')
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)
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')
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')
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)
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)
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")
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')
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')
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)
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)
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')
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)
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)
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)
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')
def load(self, track):
if track.id == Type.RADIOS:
RadioPlayer.load(self, track)
else:
BinPlayer.load(self, track)