def _show_subtoolbar(self, show):
"""
Show/hide subtoolbar
@param show as bool
"""
is_visible = self._subtoolbar.is_visible()
if show and not is_visible:
mini = MiniPlayer()
mini.show()
self._subtoolbar.add(mini)
self._subtoolbar.show()
elif not show and is_visible:
children = self._subtoolbar.get_children()
if children:
children[0].destroy()
self._subtoolbar.hide()
def _show_subtoolbar(self, show):
"""
Show/hide subtoolbar
@param show as bool
"""
is_visible = self._subtoolbar.is_visible()
if show and not is_visible:
mini = MiniPlayer()
mini.show()
self._subtoolbar.add(mini)
self._subtoolbar.show()
elif not show and is_visible:
children = self._subtoolbar.get_children()
if children:
children[0].destroy()
self._subtoolbar.hide()
def _show_miniplayer(self, show):
"""
Show/hide miniplayer
@param show as bool
"""
mini = self._main_stack.get_child_by_name("mini")
if show:
if mini is not None:
if self._timeout is not None:
GLib.source_remove(self._timeout)
else:
mini = MiniPlayer()
self._main_stack.add_named(mini, "mini")
self._timeout = None
mini.show()
self._main_stack.set_visible_child_name("mini")
self._toolbar.set_show_close_button(False)
elif mini is not None and not show and self._timeout is None:
self._main_stack.set_visible_child_name("main")
self._toolbar.set_show_close_button(not Lp().settings.get_value("disable-csd"))
self._timeout = GLib.timeout_add(1000, mini.destroy)
def _show_miniplayer(self, show):
"""
Show/hide miniplayer
@param show as bool
"""
mini = self._main_stack.get_child_by_name('mini')
if show:
if mini is not None:
if self._timeout is not None:
GLib.source_remove(self._timeout)
else:
mini = MiniPlayer()
self._main_stack.add_named(mini, 'mini')
self._timeout = None
mini.show()
self._main_stack.set_visible_child_name('mini')
self._toolbar.set_show_close_button(False)
elif mini is not None and not show and self._timeout is None:
self._main_stack.set_visible_child_name('main')
self._toolbar.set_show_close_button(
not Lp().settings.get_value('disable-csd'))
self._timeout = GLib.timeout_add(1000, mini.destroy)
def __show_miniplayer(self, show):
"""
Show/hide miniplayer
@param show as bool
"""
mini = self.__main_stack.get_child_by_name("mini")
if show:
if mini is not None:
if self.__timeout is not None:
GLib.source_remove(self.__timeout)
else:
from lollypop.miniplayer import MiniPlayer
mini = MiniPlayer()
self.__main_stack.add_named(mini, "mini")
self.__timeout = None
mini.show()
self.__main_stack.set_visible_child_name("mini")
self.__toolbar.set_show_close_button(False)
elif mini is not None and not show and self.__timeout is None:
self.__main_stack.set_visible_child_name("main")
self.__toolbar.set_show_close_button(
not Lp().settings.get_value("disable-csd") and not is_unity())
self.__timeout = GLib.timeout_add(1000, mini.destroy)
def __show_miniplayer(self, show):
"""
Show/hide miniplayer
@param show as bool
"""
mini = self.__main_stack.get_child_by_name('mini')
if show:
if mini is not None:
if self.__timeout is not None:
GLib.source_remove(self.__timeout)
else:
from lollypop.miniplayer import MiniPlayer
mini = MiniPlayer()
self.__main_stack.add_named(mini, 'mini')
self.__timeout = None
mini.show()
self.__main_stack.set_visible_child_name('mini')
self.__toolbar.set_show_close_button(False)
elif mini is not None and not show and self.__timeout is None:
self.__main_stack.set_visible_child_name('main')
self.__toolbar.set_show_close_button(
not Lp().settings.get_value('disable-csd') and
not is_unity())
self.__timeout = GLib.timeout_add(1000, mini.destroy)
class Window(Gtk.ApplicationWindow, SignalsHelper):
"""
Main window
"""
@signals_map
def __init__(self):
"""
Init window
"""
Gtk.ApplicationWindow.__init__(self,
application=App(),
title="Lollypop",
icon_name="org.gnome.Lollypop")
self.__miniplayer = None
self.__configure_timeout_id = None
self.set_auto_startup_notification(False)
self.connect("realize", self.__on_realize)
# Does not work with a Gtk.Gesture in GTK3
self.connect("button-release-event", self.__on_button_release_event)
self.connect("window-state-event", self.__on_window_state_event)
self.connect("configure-event", self.__on_configure_event)
self.connect("destroy", self.__on_destroy)
return [(App().player, "current-changed", "_on_current_changed")]
def setup(self):
"""
Setup window content
"""
self.__vgrid = Gtk.Grid()
self.__vgrid.set_orientation(Gtk.Orientation.VERTICAL)
self.__vgrid.show()
self.__container = Container()
self.__container.setup()
self.__container.show()
self.__toolbar = Toolbar(self)
self.__toolbar.show()
if App().settings.get_value("disable-csd") or is_unity():
self.__vgrid.add(self.__toolbar)
else:
self.set_titlebar(self.__toolbar)
self.__toolbar.set_show_close_button(
not App().settings.get_value("disable-csd"))
self.__vgrid.add(self.__container)
self.add(self.__vgrid)
self.__container.widget.connect("notify::folded",
self.__on_container_folded)
def show_miniplayer(self, show, reveal=False):
"""
Show/hide subtoolbar
@param show as bool
@param reveal as bool
"""
def show_buttons(show):
if show:
self.toolbar.end.show()
self.toolbar.playback.show()
else:
self.toolbar.end.hide()
self.toolbar.playback.hide()
def on_revealed(miniplayer, revealed):
miniplayer.set_vexpand(revealed)
show_buttons(not revealed)
if revealed:
self.__container.hide()
emit_signal(self.__container, "can-go-back-changed", False)
else:
self.__container.show()
emit_signal(self.__container, "can-go-back-changed",
self.__container.can_go_back)
if show and self.__miniplayer is None:
from lollypop.miniplayer import MiniPlayer
self.__miniplayer = MiniPlayer()
if App().player.current_track.id is not None:
self.__miniplayer.show()
self.__miniplayer.connect("revealed", on_revealed)
self.__vgrid.add(self.__miniplayer)
self.__miniplayer.set_vexpand(False)
elif not show and self.__miniplayer is not None:
if App().lookup_action("miniplayer").get_state():
App().lookup_action("miniplayer").change_state(
GLib.Variant("b", False))
else:
self.__miniplayer.destroy()
self.__miniplayer = None
self.__container.show()
show_buttons(True)
if self.__miniplayer is not None:
if reveal:
self.__miniplayer.reveal(True)
else:
self.__miniplayer.update_artwork()
@property
def folded(self):
"""
True if window is adaptive, ie widget folded
"""
return App().window.container.widget.get_folded()
@property
def miniplayer(self):
"""
@return MiniPlayer
"""
return self.__miniplayer
@property
def toolbar(self):
"""
@return Toolbar
"""
return self.__toolbar
@property
def container(self):
"""
@return Container
"""
return self.__container
##############
# PROTECTED #
##############
def _on_current_changed(self, player):
"""
Update toolbar
@param player as Player
"""
if App().player.current_track.id is None:
self.set_title("Lollypop")
else:
artists = ", ".join(player.current_track.artists)
self.set_title("%s - %s" % (artists, player.current_track.name))
if self.__miniplayer is not None:
self.__miniplayer.show()
def _on_configure_event_timeout(self, width, height, x, y):
"""
Setup content based on current size
@param width as int
@param height as int
@param x as int
@param y as int
"""
self.__configure_timeout_id = None
if App().lookup_action("miniplayer").get_state():
return
if not self.is_maximized():
# Keep a minimal height
if height < AdaptiveSize.SMALL:
height = AdaptiveSize.SMALL
App().settings.set_value("window-size",
GLib.Variant("ai", [width, height]))
App().settings.set_value("window-position", GLib.Variant("ai", [x, y]))
############
# PRIVATE #
############
def __setup_size_and_position(self):
"""
Setup window position and size, callbacks
"""
try:
size = App().settings.get_value("window-size")
pos = App().settings.get_value("window-position")
self.resize(size[0], size[1])
self.move(pos[0], pos[1])
if App().settings.get_value("window-maximized"):
self.maximize()
except Exception as e:
Logger.error("Window::__setup_size_and_position(): %s", e)
def __on_realize(self, window):
"""
Init window content
@param window as Gtk.Window
"""
self.__setup_size_and_position()
if App().settings.get_value("auto-update") or App().tracks.is_empty():
# Delayed, make python segfault on sys.exit() otherwise
# No idea why, maybe scanner using Gstpbutils before Gstreamer
# initialisation is finished...
GLib.timeout_add(1000, App().scanner.update, ScanType.FULL)
def __on_button_release_event(self, window, event):
"""
Handle special mouse buttons
@param window as Gtk.Window
@param event as Gdk.EventButton
"""
if event.button == 8:
App().window.container.go_back()
return True
def __on_window_state_event(self, widget, event):
"""
Save maximised state
"""
if not App().lookup_action("miniplayer").get_state():
App().settings.set_boolean(
"window-maximized", "GDK_WINDOW_STATE_MAXIMIZED"
in event.new_window_state.value_names)
def __on_container_folded(self, leaflet, folded):
"""
show/hide miniplayer
@param leaflet as Handy.Leaflet
@param folded as Gparam
"""
self.show_miniplayer(App().window.folded)
def __on_destroy(self, widget):
"""
Remove ref cycle, just to prevent output on DEBUG_LEAK
@param widget as Gtk.Widget
"""
self.__toolbar = None
def __on_configure_event(self, window, event):
"""
Delay event
@param window as Gtk.Window
@param event as Gdk.EventConfigure
"""
if self.__configure_timeout_id:
GLib.source_remove(self.__configure_timeout_id)
(width, height) = window.get_size()
(x, y) = window.get_position()
self.__configure_timeout_id = GLib.idle_add(
self._on_configure_event_timeout,
width,
height,
x,
y,
priority=GLib.PRIORITY_LOW)
