soreaus menu: Implement logout dialog

applets/soreaus-menu/__init__.py

@@ -29,10 +29,112 @@ import panorama_panel

                                
                                
                                
                            
                                
                                    
                                        
                                            29  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            30  
                                            import gi
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            31  
                                            gi.require_version("Gtk", "4.0")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        32 +
                                        gi.require_version("Gtk4LayerShell", "1.0")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            33  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        33 -
                                        from gi.repository import Gtk, GLib, Gio, Gdk, Pango
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        34 +
                                        from gi.repository import Gtk, GLib, Gtk4LayerShell, Gio, Gdk, Pango
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            35  
                                            import subprocess
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            36  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        37 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        38 +
                                        LOGOUT_BUTTON_SIZE = 125
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        39 +
                                        LOGOUT_BUTTON_MARGIN = 10
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        40 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        41 +
                                        def create_logout_ui_button(icon_name, label_text):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        42 +
                                            layout = Gtk.Box()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        43 +
                                            image = Gtk.Image()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        44 +
                                            label = Gtk.Label()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        45 +
                                            button = Gtk.Button()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        46 +
                                            button.set_size_request(LOGOUT_BUTTON_SIZE, LOGOUT_BUTTON_SIZE)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        47 +
                                            image.set_from_icon_name(icon_name)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        48 +
                                            label.set_text(label_text)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        49 +
                                            layout.set_orientation(Gtk.Orientation.VERTICAL)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        50 +
                                            layout.set_halign(Gtk.Align.CENTER)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        51 +
                                            layout.append(image)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        52 +
                                            image.set_icon_size(Gtk.IconSize.LARGE)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        53 +
                                            image.set_vexpand(True)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        54 +
                                            layout.append(label)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        55 +
                                            button.set_child(layout)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        56 +
                                            return button
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        57 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        58 +
                                        class WayfireLogoutUI(Gtk.Window):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        59 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        60 +
                                            def __init__(self):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        61 +
                                                super().__init__()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        62 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        63 +
                                                hbox = Gtk.CenterBox()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        64 +
                                                main_layout = Gtk.Grid()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        65 +
                                                suspend = create_logout_ui_button("emblem-synchronizing", "Suspend")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        66 +
                                                suspend.connect("clicked", self.on_suspend_click)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        67 +
                                                main_layout.attach(suspend, 0, 0, 1, 1)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        68 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        69 +
                                                hibernate = create_logout_ui_button("weather-clear-night", "Hibernate")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        70 +
                                                hibernate.connect("clicked", self.on_hibernate_click)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        71 +
                                                main_layout.attach(hibernate, 1, 0, 1, 1)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        72 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        73 +
                                                switchuser = create_logout_ui_button("system-users", "Switch User")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        74 +
                                                switchuser.connect("clicked", self.on_switchuser_click)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        75 +
                                                main_layout.attach(switchuser, 2, 0, 1, 1)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        76 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        77 +
                                                logout = create_logout_ui_button("system-log-out", "Log Out")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        78 +
                                                logout.connect("clicked", self.on_logout_click)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        79 +
                                                main_layout.attach(logout, 0, 1, 1, 1)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        80 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        81 +
                                                reboot = create_logout_ui_button("system-reboot", "Reboot")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        82 +
                                                reboot.connect("clicked", self.on_reboot_click)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        83 +
                                                main_layout.attach(reboot, 1, 1, 1, 1)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        84 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        85 +
                                                shutdown = create_logout_ui_button("system-shutdown", "Shut Down")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        86 +
                                                shutdown.connect("clicked", self.on_shutdown_click)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        87 +
                                                main_layout.attach(shutdown, 2, 1, 1, 1)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        88 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        89 +
                                                cancel_button = Gtk.Button()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        90 +
                                                cancel_button.set_size_request(100, 50)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        91 +
                                                cancel_button.set_label("Cancel")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        92 +
                                                main_layout.attach(cancel_button, 1, 2, 1, 1)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        93 +
                                                cancel_button.connect("clicked", self.on_cancel_click)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        94 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        95 +
                                                main_layout.set_row_spacing(LOGOUT_BUTTON_MARGIN)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        96 +
                                                main_layout.set_column_spacing(LOGOUT_BUTTON_MARGIN)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        97 +
                                                # Make surfaces layer shell
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        98 +
                                                Gtk4LayerShell.init_for_window(self)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        99 +
                                                Gtk4LayerShell.set_namespace(self, "com.roundabout_host.panorama.logout")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        100 +
                                                Gtk4LayerShell.set_layer(self, Gtk4LayerShell.Layer.OVERLAY)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        101 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        102 +
                                                Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.TOP, True)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        103 +
                                                Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.BOTTOM, True)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        104 +
                                                Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.LEFT, True)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        105 +
                                                Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.RIGHT, True)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        106 +
                                                main_layout.set_valign(Gtk.Align.CENTER)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        107 +
                                                hbox.set_center_widget(main_layout)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        108 +
                                                hbox.set_hexpand(True)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        109 +
                                                hbox.set_vexpand(True)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        110 +
                                                self.set_child(hbox)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        111 +
                                                self.get_style_context().add_class("logout")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        112 +
                                                display = self.get_display()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        113 +
                                                css_provider = Gtk.CssProvider()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        114 +
                                                css_provider.load_from_data("window.logout { background-color: rgba(0, 0, 0, 0.5); }")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        115 +
                                                Gtk.StyleContext.add_provider_for_display(display, css_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        116 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        117 +
                                            def on_suspend_click(self, button):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        118 +
                                                GLib.spawn_command_line_async("systemctl suspend")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        119 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        120 +
                                            def on_hibernate_click(self, button):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        121 +
                                                GLib.spawn_command_line_async("systemctl hibernate")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        122 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        123 +
                                            def on_switchuser_click(self, button):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        124 +
                                                GLib.spawn_command_line_async("dm-tool switch-to-greeter")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        125 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        126 +
                                            def on_logout_click(self, button):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        127 +
                                                GLib.spawn_command_line_async("wayland-logout")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        128 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        129 +
                                            def on_reboot_click(self, button):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        130 +
                                                GLib.spawn_command_line_async("systemctl reboot")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        131 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        132 +
                                            def on_shutdown_click(self, button):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        133 +
                                                GLib.spawn_command_line_async("systemctl poweroff")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        134 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        135 +
                                            def on_cancel_click(self, button):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        136 +
                                                self.hide()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        137 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            138  
                                            class SoreausMenu(panorama_panel.Applet):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            139  
                                                name = "Soreau's menu"
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            140  
                                                description = "Flowbox app menu"
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -42,6 +144,7 @@ class SoreausMenu(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            144  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            145  
                                                    self.button = Gtk.MenuButton()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            146  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        147 +
                                                self.menu_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            148  
                                                    image = Gtk.Image.new_from_icon_name("wayfire")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            149  
                                                    image.set_icon_size(Gtk.IconSize.LARGE)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            150  
                                                    self.append(self.button)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -52,11 +155,29 @@ class SoreausMenu(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            155  
                                                    self.flowbox_item_focus_signal = self.flowbox.connect("selected-children-changed", self.on_flowbox_item_focus)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            156  
                                                    self.populate_menu_entries()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            157  
                                                    self.scrolled_window = Gtk.ScrolledWindow()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        158 +
                                                self.scrolled_window.set_size_request(-1, 350)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            159  
                                                    self.scrolled_window.set_child(self.flowbox)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        56 -
                                                self.popover.set_child(self.scrolled_window)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        160 +
                                                self.logout_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        161 +
                                                self.logout_button = Gtk.Button()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        162 +
                                                self.logout_button.set_margin_top(5)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        163 +
                                                self.logout_button.set_margin_bottom(5)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        164 +
                                                self.logout_button.set_margin_start(5)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        165 +
                                                self.logout_button.set_margin_end(5)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        166 +
                                                self.logout_button.set_child(Gtk.Image.new_from_icon_name("system-shutdown"))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        167 +
                                                self.logout_button.connect("clicked", self.on_logout_button_clicked)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        168 +
                                                self.logout_box.set_halign(Gtk.Align.END)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        169 +
                                                self.logout_box.append(self.logout_button)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        170 +
                                                self.menu_box.append(self.scrolled_window)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        171 +
                                                self.menu_box.append(self.logout_box)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        172 +
                                                self.popover.set_child(self.menu_box)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            173  
                                                    self.popover.set_size_request(300, 400)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            174  
                                                    self.popover.connect("show", self.on_popover_popup)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            175  
                                                    self.button.set_popover(self.popover)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        176 +
                                                self.logout_ui = WayfireLogoutUI()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        177 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        178 +
                                            def on_logout_button_clicked(self, button):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        179 +
                                                self.logout_ui.present()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        180 +
                                                self.popover.popdown()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            181  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            182  
                                                def on_flowbox_item_focus(self, flowbox):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            183  
                                                    selected_children = flowbox.get_selected_children()