def next(self):
"""
Return next radio name, uri
@return Track
"""
track = Track()
if self.current_track.id != Type.RADIOS:
return track
radios_manager = Radios()
radios = radios_manager.get()
i = 0
for (name, url) in radios:
i += 1
if self.current_track.album_artist == name:
break
# Get next radio
if i >= len(radios):
i = 0
name = radios[i][0]
url = radios[i][1]
if url:
track.set_radio(name, url)
return track
def prev(self):
"""
Return prev radio name, uri
@return Track
"""
track = Track()
if self.current_track.id != Type.RADIOS:
return track
radios_manager = Radios()
radios = radios_manager.get()
i = len(radios) - 1
for (name, url) in reversed(radios):
i -= 1
if self.current_track.album_artist == name:
break
# Get prev radio
if i < 0:
i = len(radios) - 1
name = radios[i][0]
url = radios[i][1]
if url:
track.set_radio(name, url)
return track
def prev(self):
"""
Return prev radio name, uri
@return Track
"""
track = Track()
if self.current_track.id != Type.RADIOS:
return track
radios_manager = Radios()
radios = radios_manager.get()
i = len(radios) - 1
for (name, url) in reversed(radios):
i -= 1
if self.current_track.album_artist == name:
break
# Get prev radio
if i < 0:
i = len(radios) - 1
name = radios[i][0]
url = radios[i][1]
if url:
track.set_radio(name, url)
return track
def next(self):
"""
Return next radio name, uri
@return Track
"""
track = Track()
if self.current_track.id != Type.RADIOS:
return track
radios_manager = Radios()
radios = radios_manager.get()
i = 0
for (name, url) in radios:
i += 1
if self.current_track.album_artist == name:
break
# Get next radio
if i >= len(radios):
i = 0
name = radios[i][0]
url = radios[i][1]
if url:
track.set_radio(name, url)
return track
class RadiosView(View):
"""
Show radios in a grid
"""
def __init__(self):
"""
Init view
"""
View.__init__(self)
self._signal = Lp().art.connect('radio-artwork-changed',
self._on_logo_changed)
self._radios_manager = Radios()
self._radios_manager.connect('radios-changed',
self._on_radios_changed)
builder = Gtk.Builder()
builder.add_from_resource('/org/gnome/Lollypop/RadiosView.ui')
builder.connect_signals(self)
widget = builder.get_object('widget')
self._empty = builder.get_object('empty')
self._pop_tunein = TuneinPopover(self._radios_manager)
self._pop_tunein.set_relative_to(builder.get_object('search_btn'))
self._sizegroup = Gtk.SizeGroup(mode=Gtk.SizeGroupMode.BOTH)
self._radiobox = Gtk.FlowBox()
self._radiobox.set_selection_mode(Gtk.SelectionMode.NONE)
self._radiobox.connect("child-activated", self._on_album_activated)
self._radiobox.set_property('column-spacing', 5)
self._radiobox.set_property('row-spacing', 5)
self._radiobox.set_homogeneous(True)
self._radiobox.set_max_children_per_line(1000)
self._radiobox.show()
self._stack = Gtk.Stack()
self._stack.set_transition_duration(500)
self._stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE)
self._stack.add(self._scrolled)
self._stack.add(self._empty)
self._stack.show()
self._viewport.set_property("valign", Gtk.Align.START)
self._viewport.set_property('margin', 5)
self._viewport.add(self._radiobox)
self._scrolled.set_property('expand', True)
self.add(widget)
self.add(self._stack)
def populate(self):
"""
Populate view with tracks from playlist
Thread safe
"""
Lp().player.set_radios(self._radios_manager.get())
if Lp().player.current_track.id == Type.RADIOS:
Lp().player.set_next() # We force next update
Lp().player.set_prev() # We force prev update
t = Thread(target=self._populate)
t.daemon = True
t.start()
#######################
# PRIVATE #
#######################
def _populate(self):
"""
Populate view with tracks from playlist
Thread safe
"""
radios = []
# Get radios name
for (name, url) in self._radios_manager.get():
radios.append(name)
GLib.idle_add(self._show_stack, radios)
def _get_children(self):
"""
Return view children
@return [RadioWidget]
"""
children = []
for child in self._radiobox.get_children():
widget = child.get_child()
children.append(widget)
return children
def _on_destroy(self, widget):
"""
Disconnect signals
@param widget as Gtk.Widget
"""
if self._signal is not None:
Lp().art.disconnect(self._signal)
def _on_new_clicked(self, widget):
"""
Show popover for adding a new radio
@param widget as Gtk.Widget
"""
popover = RadioPopover('', self._radios_manager)
popover.set_relative_to(widget)
popover.show()
def _on_search_clicked(self, widget):
"""
Show popover for searching radios
@param widget as Gtk.Widget
"""
self._pop_tunein.populate()
self._pop_tunein.show()
def _on_radios_changed(self, manager):
"""
Update radios
@param manager as PlaylistManager
"""
radios_name = []
currents = []
new_name = None
old_widget = None
old_child = None
# Get radios name
for (name, url) in manager.get():
radios_name.append(name)
# Get currents widget less removed
for child in self._radiobox.get_children():
widget = child.get_child()
if widget.get_name() not in radios_name:
old_widget = widget
old_child = child
else:
currents.append(widget.get_name())
# Add the new radio
for name in radios_name:
if name not in currents:
new_name = name
break
# Rename widget
if new_name is not None:
if old_widget is not None:
old_widget.set_name(new_name)
else:
radios = [new_name]
self._show_stack(radios)
# Delete widget
elif old_widget is not None:
self._radiobox.remove(old_child)
old_widget.destroy()
if not self._radiobox.get_children():
self._show_stack([])
# Update player state based on current view
radios = []
for child in self._radiobox.get_children():
widget = child.get_child()
name = widget.get_name()
url = manager.get_url(name)
radios.append((name, url))
Lp().player.set_radios(radios)
if Lp().player.current_track.id == Type.RADIOS:
Lp().player.set_next() # We force next update
Lp().player.set_prev() # We force prev update
def _on_logo_changed(self, player, name):
"""
Update radio logo
@param player as Plyaer
@param name as string
"""
for child in self._radiobox.get_children():
widget = child.get_child()
if widget.get_name() == name:
widget.update_cover()
def _show_stack(self, radios):
"""
Switch empty/radios view based on radios
@param [radio names as string]
"""
if radios:
self._stack.set_visible_child(self._scrolled)
self._add_radios(radios, True)
else:
self._stack.set_visible_child(self._empty)
def _add_radios(self, radios, first=False):
"""
Pop a radio and add it to the view,
repeat operation until radio list is empty
@param [radio names as string]
@param first as bool
"""
if radios and not self._stop:
radio = radios.pop(0)
widget = RadioWidget(radio,
self._radios_manager)
widget.show()
self._sizegroup.add_widget(widget)
if first:
self._radiobox.insert(widget, 0)
else:
self._radiobox.insert(widget, -1)
GLib.idle_add(self._add_radios, radios)
else:
self._stop = False
return None
def _on_album_activated(self, flowbox, child):
"""
Play album
@param flowbox as Gtk.Flowbox
@child as Gtk.FlowboxChild
"""
name = child.get_child().get_name()
url = self._radios_manager.get_url(name)
if url:
track = Track()
track.set_radio(name, url)
Lp().player.load(track)
class RadiosView(View):
"""
Show radios in a grid
"""
def __init__(self):
"""
Init view
"""
View.__init__(self)
self._signal = Lp().art.connect('radio-artwork-changed',
self._on_logo_changed)
self._radios_manager = Radios()
self._radios_manager.connect('radios-changed', self._on_radios_changed)
builder = Gtk.Builder()
builder.add_from_resource('/org/gnome/Lollypop/RadiosView.ui')
builder.connect_signals(self)
widget = builder.get_object('widget')
self._empty = builder.get_object('empty')
self._pop_tunein = TuneinPopover(self._radios_manager)
self._pop_tunein.set_relative_to(builder.get_object('search_btn'))
self._sizegroup = Gtk.SizeGroup(mode=Gtk.SizeGroupMode.BOTH)
self._radiobox = Gtk.FlowBox()
self._radiobox.set_selection_mode(Gtk.SelectionMode.NONE)
self._radiobox.connect("child-activated", self._on_album_activated)
self._radiobox.set_property('column-spacing', 5)
self._radiobox.set_property('row-spacing', 5)
self._radiobox.set_homogeneous(True)
self._radiobox.set_max_children_per_line(1000)
self._radiobox.show()
self._stack = Gtk.Stack()
self._stack.set_transition_duration(500)
self._stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE)
self._stack.add(self._scrolledWindow)
self._stack.add(self._empty)
self._stack.show()
self._viewport.set_property("valign", Gtk.Align.START)
self._viewport.set_property('margin', 5)
self._viewport.add(self._radiobox)
self._scrolledWindow.set_property('expand', True)
self.add(widget)
self.add(self._stack)
def populate(self):
"""
Populate view with tracks from playlist
Thread safe
"""
t = Thread(target=self._populate)
t.daemon = True
t.start()
#######################
# PRIVATE #
#######################
def _populate(self):
"""
Populate view with tracks from playlist
Thread safe
"""
radios = []
# Get radios name
for (name, url) in self._radios_manager.get():
radios.append(name)
GLib.idle_add(self._show_stack, radios)
def _get_children(self):
"""
Return view children
@return [RadioWidget]
"""
children = []
for child in self._radiobox.get_children():
widget = child.get_child()
children.append(widget)
return children
def _on_destroy(self, widget):
"""
Disconnect signals
@param widget as Gtk.Widget
"""
if self._signal is not None:
Lp().art.disconnect(self._signal)
def _on_new_clicked(self, widget):
"""
Show popover for adding a new radio
@param widget as Gtk.Widget
"""
popover = RadioPopover('', self._radios_manager)
popover.set_relative_to(widget)
popover.show()
def _on_search_clicked(self, widget):
"""
Show popover for searching radios
@param widget as Gtk.Widget
"""
self._pop_tunein.populate()
self._pop_tunein.show()
def _on_radios_changed(self, manager):
"""
Update radios
@param manager as PlaylistManager
"""
radios_name = []
currents = []
new_name = None
old_widget = None
old_child = None
# Get radios name
for (name, url) in manager.get():
radios_name.append(name)
# Get currents widget less removed
for child in self._radiobox.get_children():
widget = child.get_child()
if widget.get_name() not in radios_name:
old_widget = widget
old_child = child
else:
currents.append(widget.get_name())
# Add the new radio
for name in radios_name:
if name not in currents:
new_name = name
break
# Rename widget
if new_name is not None:
if old_widget is not None:
old_widget.set_name(new_name)
else:
radios = [new_name]
self._show_stack(radios)
# Delete widget
elif old_widget is not None:
self._radiobox.remove(old_child)
old_widget.destroy()
if not self._radiobox.get_children():
self._show_stack([])
def _on_logo_changed(self, player, name):
"""
Update radio logo
@param player as Plyaer
@param name as string
"""
for child in self._radiobox.get_children():
widget = child.get_child()
if widget.get_name() == name:
widget.update_cover()
def _show_stack(self, radios):
"""
Switch empty/radios view based on radios
@param [radio names as string]
"""
if radios:
self._stack.set_visible_child(self._scrolledWindow)
self._add_radios(radios, True)
else:
self._stack.set_visible_child(self._empty)
def _add_radios(self, radios, first=False):
"""
Pop a radio and add it to the view,
repeat operation until radio list is empty
@param [radio names as string]
@param first as bool
"""
if radios and not self._stop:
radio = radios.pop(0)
widget = RadioWidget(radio, self._radios_manager)
widget.show()
self._sizegroup.add_widget(widget)
if first:
self._radiobox.insert(widget, 0)
else:
self._radiobox.insert(widget, -1)
GLib.idle_add(self._add_radios, radios)
else:
self._stop = False
return None
def _on_album_activated(self, flowbox, child):
"""
Play album
@param flowbox as Gtk.Flowbox
@child as Gtk.FlowboxChild
"""
name = child.get_child().get_name()
url = self._radios_manager.get_url(name)
if url:
track = Track()
track.set_radio(name, url)
Lp().player.load(track)
class RadiosView(LazyLoadingView):
"""
Show radios in a grid
"""
def __init__(self):
"""
Init view
"""
LazyLoadingView.__init__(self, True)
self.__signal = Lp().art.connect("radio-artwork-changed",
self.__on_logo_changed)
self.__radios_manager = Radios()
self.__radios_manager.connect("radios-changed",
self.__on_radios_changed)
builder = Gtk.Builder()
builder.add_from_resource("/org/gnome/Lollypop/RadiosView.ui")
builder.connect_signals(self)
widget = builder.get_object("widget")
self.__empty = builder.get_object("empty")
self.__pop_tunein = TuneinPopover(self.__radios_manager)
self.__pop_tunein.set_relative_to(builder.get_object("search_btn"))
self._box = Gtk.FlowBox()
self._box.set_selection_mode(Gtk.SelectionMode.NONE)
# Allow lazy loading to not jump up and down
self._box.set_homogeneous(True)
self._box.set_max_children_per_line(1000)
self._box.set_filter_func(self._filter_func)
self._box.show()
self.__stack = Gtk.Stack()
self.__stack.set_transition_duration(500)
self.__stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE)
self.__stack.add(self._scrolled)
self.__stack.add(self.__empty)
self.__stack.show()
self._viewport.set_property("valign", Gtk.Align.START)
self._viewport.set_property("margin", 5)
self._scrolled.set_property("expand", True)
self.add(widget)
self.add(self.__stack)
def populate(self):
"""
Populate view with tracks from playlist
"""
Lp().player.set_radios(self.__radios_manager.get())
if Lp().player.current_track.id == Type.RADIOS:
Lp().player.set_next() # We force next update
Lp().player.set_prev() # We force prev update
helper = TaskHelper()
helper.run(self.__get_radios, callback=(self.__on_get_radios, ))
#######################
# PROTECTED #
#######################
def _get_children(self):
"""
Return view children
@return [RadioWidget]
"""
children = []
for child in self._box.get_children():
children.append(child)
return children
def _on_destroy(self, widget):
"""
Disconnect signals
@param widget as Gtk.Widget
"""
LazyLoadingView._on_destroy(self, widget)
if self.__signal is not None:
Lp().art.disconnect(self.__signal)
def _on_new_clicked(self, widget):
"""
Show popover for adding a new radio
@param widget as Gtk.Widget
"""
popover = RadioPopover("", self.__radios_manager)
popover.set_relative_to(widget)
popover.show()
def _on_search_clicked(self, widget):
"""
Show popover for searching radios
@param widget as Gtk.Widget
"""
self.__pop_tunein.populate()
self.__pop_tunein.show()
#######################
# PRIVATE #
#######################
def __get_radios(self):
"""
Get radios
@return [name]
"""
radios = []
# Get radios name
for (name, url) in self.__radios_manager.get():
radios.append(name)
return radios
def __on_radios_changed(self, manager):
"""
Update radios
@param manager as PlaylistManager
"""
radios_name = []
currents = []
new_name = None
old_child = None
# Get radios name
for (name, url) in manager.get():
radios_name.append(name)
# Get currents widget less removed
for child in self._box.get_children():
if child.title not in radios_name:
old_child = child
else:
currents.append(child.title)
# Add the new radio
for name in radios_name:
if name not in currents:
new_name = name
break
# Rename widget
if new_name is not None:
if old_child is not None:
old_child.set_name(new_name)
else:
radios = [new_name]
self.__show_stack(radios)
# Delete widget
elif old_child is not None:
old_child.destroy()
if not self._box.get_children():
self.__show_stack([])
# Update player state based on current view
radios = []
for child in self._box.get_children():
name = child.title
url = manager.get_url(name)
radios.append((name, url))
Lp().player.set_radios(radios)
if Lp().player.current_track.id == Type.RADIOS:
Lp().player.set_next() # We force next update
Lp().player.set_prev() # We force prev update
def __show_stack(self, radios):
"""
Switch empty/radios view based on radios
@param [radio names as string]
"""
if radios:
self.__stack.set_visible_child(self._scrolled)
self.__add_radios(radios, True)
else:
self.__stack.set_visible_child(self.__empty)
def __add_radios(self, radios, first=False):
"""
Pop a radio and add it to the view,
repeat operation until radio list is empty
@param [radio names as string]
@param first as bool
"""
if self._stop:
self._stop = False
return
if radios:
radio = radios.pop(0)
widget = RadioWidget(radio, self.__radios_manager)
widget.connect("overlayed", self._on_overlayed)
widget.show()
self._lazy_queue.append(widget)
if first:
self._box.insert(widget, 0)
else:
self._box.insert(widget, -1)
GLib.idle_add(self.__add_radios, radios)
else:
GLib.idle_add(self.lazy_loading)
if self._viewport.get_child() is None:
self._viewport.add(self._box)
def __on_logo_changed(self, player, name):
"""
Update radio logo
@param player as Plyaer
@param name as string
"""
for child in self._box.get_children():
if child.title == name:
child.update_cover()
def __on_get_radios(self, radios):
"""
Switch empty/radios view based on radios
@param [radio names as string]
"""
if radios:
self.__stack.set_visible_child(self._scrolled)
self.__add_radios(radios, True)
else:
self.__stack.set_visible_child(self.__empty)
