window-list: Initial framework for live window preview tooltips

applets/wf-window-list/__init__.py

@@ -20,16 +20,23 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.

                                
                                
                                
                            
                                
                                    
                                        
                                            20  
                                            import dataclasses
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            21  
                                            import os
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            22  
                                            import sys
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        23 +
                                        import mmap
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            24  
                                            import locale
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            25  
                                            import typing
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            26  
                                            from pathlib import Path
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        27 +
                                        from pywayland.utils import AnonymousFile
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            28  
                                            from pywayland.client import Display, EventQueue
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        27 -
                                        from pywayland.protocol.wayland import WlRegistry, WlSeat, WlSurface, WlCompositor, WlOutput
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        29 +
                                        from pywayland.protocol.wayland import WlRegistry, WlSeat, WlSurface, WlCompositor, WlOutput, WlBuffer, WlShm, WlShmPool
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            30  
                                            from pywayland.protocol.wayland.wl_output import WlOutputProxy
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            31  
                                            from pywayland.protocol.wlr_foreign_toplevel_management_unstable_v1 import (
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            32  
                                                ZwlrForeignToplevelManagerV1,
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            33  
                                                ZwlrForeignToplevelHandleV1
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            34  
                                            )
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        35 +
                                        from pywayland.protocol.wlr_screencopy_unstable_v1 import (
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        36 +
                                            ZwlrScreencopyManagerV1,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        37 +
                                            ZwlrScreencopyFrameV1
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        38 +
                                        )
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        39 +
                                        from OpenGL import GL
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            40  
                                            import panorama_panel
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            41  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            42  
                                            import gi
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -158,10 +165,12 @@ class WindowButtonLayoutManager(Gtk.LayoutManager):

                                
                                
                                
                            
                                
                                    
                                        
                                            165  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            166  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            167  
                                            class WindowButton(Gtk.ToggleButton):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        161 -
                                            def __init__(self, window_id, window_title, **kwargs):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        168 +
                                            def __init__(self, window_id, window_title, window_list, **kwargs):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            169  
                                                    super().__init__(**kwargs)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            170  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            171  
                                                    self.window_id: ZwlrForeignToplevelHandleV1 = window_id
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        172 +
                                                self.wf_sock = window_list.wf_socket
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        173 +
                                                self.window_list = window_list
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            174  
                                                    self.wf_ipc_id: typing.Optional[int] = None
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            175  
                                                    self.set_has_frame(False)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            176  
                                                    self.label = Gtk.Label()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -220,6 +229,35 @@ class WindowButton(Gtk.ToggleButton):

                                
                                
                                
                            
                                
                                    
                                        
                                            229  
                                                    self.middle_click_controller.connect("released", self.close_associated)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            230  
                                                    self.add_controller(self.middle_click_controller)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            231  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        232 +
                                                if not self.window_list.live_preview_tooltips:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        233 +
                                                    return
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        234 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        235 +
                                                self.custom_tooltip_content = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        236 +
                                                self.custom_tooltip_content.append(TooltipMedia(window_list))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        237 +
                                                self.hover_point = 0, 0
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        238 +
                                                self.hover_timeout = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        239 +
                                                self.connect("query-tooltip", self.query_tooltip)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        240 +
                                                self.set_has_tooltip(True)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        241 +
                                                motion_controller = Gtk.EventControllerMotion()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        242 +
                                                motion_controller.connect("enter", self.on_button_enter)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        243 +
                                                motion_controller.connect("leave", self.on_button_leave)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        244 +
                                                self.add_controller(motion_controller)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        245 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        246 +
                                            def query_tooltip(self, widget, x, y, keyboard_mode, tooltip):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        247 +
                                                tooltip.set_custom(self.custom_tooltip_content)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        248 +
                                                return True
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        249 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        250 +
                                            def on_button_enter(self, button, x, y):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        251 +
                                                view_id = self.wf_ipc_id
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        252 +
                                                self.window_list.set_live_preview_output_name("live-preview-" + str(view_id))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        253 +
                                                message = self.window_list.get_msg_template("live_previews/request_stream")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        254 +
                                                message["data"]["id"] = view_id
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        255 +
                                                self.wf_sock.send_json(message)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        256 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        257 +
                                            def on_button_leave(self, button):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        258 +
                                                message = self.window_list.get_msg_template("live_previews/release_output")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        259 +
                                                self.wf_sock.send_json(message)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        260 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            261  
                                                def show_menu(self, gesture, n_presses, x, y):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            262  
                                                    rect = Gdk.Rectangle()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            263  
                                                    rect.x = int(x)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -296,6 +334,133 @@ class WindowButton(Gtk.ToggleButton):

                                
                                
                                
                            
                                
                                    
                                        
                                            334  
                                                            # Due to a bug, the constructor may sometimes return C NULL
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            335  
                                                            pass
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            336  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        337 +
                                        class TooltipMedia(Gtk.GLArea):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        338 +
                                            def __init__(self, window_list):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        339 +
                                                super().__init__()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        340 +
                                                self.frame: ZwlrScreencopyFrameV1 = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        341 +
                                                self.screencopy_manager = window_list.screencopy_manager
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        342 +
                                                self.wl_shm = window_list.wl_shm
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        343 +
                                                self.window_list = window_list
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        344 +
                                                self.set_auto_render(False)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        345 +
                                                self.connect("render", self.on_render)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        346 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        347 +
                                                self.buffer_width = 200
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        348 +
                                                self.buffer_height = 200
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        349 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        350 +
                                                self.screencopy_data = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        351 +
                                                self.wl_buffer = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        352 +
                                                self.size = 0
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        353 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        354 +
                                                self.add_tick_callback(self.on_tick)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        355 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        356 +
                                                self.vertices = [
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        357 +
                                                    1.0, 1.0,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        358 +
                                                    -1.0, 1.0,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        359 +
                                                    -1.0, -1.0,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        360 +
                                                    1.0, -1.0,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        361 +
                                                ]
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        362 +
                                                self.uv_coords = [
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        363 +
                                                    1.0, 0.0,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        364 +
                                                    0.0, 0.0,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        365 +
                                                    0.0, 1.0,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        366 +
                                                    1.0, 1.0,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        367 +
                                                ]
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        368 +
                                                vertex_shader_source = """
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        369 +
                                                    precision highp float;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        370 +
                                                    attribute vec2 in_position;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        371 +
                                                    attribute vec2 uvpos;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        372 +
                                                    varying vec2 uv;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        373 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        374 +
                                                    void main() {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        375 +
                                                        uv = uvpos;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        376 +
                                                        gl_Position = vec4(in_position, 0.0, 1.0);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        377 +
                                                    }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        378 +
                                                """
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        379 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        380 +
                                                fragment_shader_source = """
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        381 +
                                                    precision highp float;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        382 +
                                                    uniform sampler2D texture;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        383 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        384 +
                                                    varying vec2 uv;
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        385 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        386 +
                                                    void main() {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        387 +
                                                        gl_FragColor = texture2D(texture, uv);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        388 +
                                                    }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        389 +
                                                """
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        390 +
                                                vertex_shader = GL.glCreateShader(GL.GL_VERTEX_SHADER)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        391 +
                                                fragment_shader = GL.glCreateShader(GL.GL_FRAGMENT_SHADER)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        392 +
                                                GL.glShaderSource(vertex_shader, vertex_shader_source)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        393 +
                                                GL.glShaderSource(fragment_shader, fragment_shader_source)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        394 +
                                                GL.glCompileShader(vertex_shader)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        395 +
                                                GL.glCompileShader(fragment_shader)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        396 +
                                                self.shader_program = GL.glCreateProgram()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        397 +
                                                GL.glAttachShader(self.shader_program, vertex_shader)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        398 +
                                                GL.glAttachShader(self.shader_program, fragment_shader)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        399 +
                                                GL.glLinkProgram(self.shader_program)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        400 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        401 +
                                                self.texture_id = GL.glGenTextures(1)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        402 +
                                                GL.glBindTexture(GL.GL_TEXTURE_2D, self.texture_id)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        403 +
                                                GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        404 +
                                                GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        405 +
                                                self.request_next_frame()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        406 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        407 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        408 +
                                            def frame_handle_buffer(self, frame, pixel_format, width, height, stride):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        409 +
                                                size = width * height * int(stride / width)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        410 +
                                                if self.size != size:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        411 +
                                                    self.set_size_request(width, height)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        412 +
                                                    self.size = size
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        413 +
                                                    anon_file = AnonymousFile(self.size)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        414 +
                                                    anon_file.open()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        415 +
                                                    fd = anon_file.fd
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        416 +
                                                    self.screencopy_data = mmap.mmap(fileno=fd, length=self.size, access=(mmap.ACCESS_READ | mmap.ACCESS_WRITE), offset=0)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        417 +
                                                    pool = self.wl_shm.create_pool(fd, self.size)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        418 +
                                                    self.wl_buffer = pool.create_buffer(0, width, height, stride, pixel_format)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        419 +
                                                    pool.destroy()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        420 +
                                                    anon_file.close()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        421 +
                                                    self.buffer_width = width
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        422 +
                                                    self.buffer_height = height
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        423 +
                                                self.frame.copy(self.wl_buffer)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        424 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        425 +
                                            def frame_ready(self, frame, tv_sec_hi, tv_sec_low, tv_nsec):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        426 +
                                                self.screencopy_data.seek(0)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        427 +
                                                GL.glBindTexture(GL.GL_TEXTURE_2D, self.texture_id)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        428 +
                                                GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA, self.buffer_width, self.buffer_height, 0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, self.screencopy_data.read(self.size))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        429 +
                                                self.request_next_frame()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        430 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        431 +
                                            def request_next_frame(self):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        432 +
                                                if self.frame:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        433 +
                                                    self.frame.destroy()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        434 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        435 +
                                                self.queue_render()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        436 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        437 +
                                                wl_output = self.window_list.get_live_preview_output()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        438 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        439 +
                                                if not wl_output:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        440 +
                                                    return
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        441 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        442 +
                                                self.frame = self.screencopy_manager.capture_output(1, wl_output)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        443 +
                                                self.frame.dispatcher["buffer"] = self.frame_handle_buffer
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        444 +
                                                self.frame.dispatcher["ready"] = self.frame_ready
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        445 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        446 +
                                            def on_render(self, gl_area, gl_context):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        447 +
                                                Gdk.GLContext.make_current(gl_context)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        448 +
                                                GL.glClear(GL.GL_COLOR_BUFFER_BIT)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        449 +
                                                GL.glUseProgram(self.shader_program)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        450 +
                                                GL.glBindTexture(GL.GL_TEXTURE_2D, self.texture_id)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        451 +
                                                GL.glEnableVertexAttribArray(0);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        452 +
                                                GL.glVertexAttribPointer(0, 2, GL.GL_FLOAT, GL.GL_FALSE, 0, self.vertices);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        453 +
                                                GL.glEnableVertexAttribArray(1);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        454 +
                                                GL.glVertexAttribPointer(1, 2, GL.GL_FLOAT, GL.GL_FALSE, 0, self.uv_coords);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        455 +
                                                GL.glDrawArrays(GL.GL_TRIANGLE_FAN, 0, 4);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        456 +
                                                GL.glDisableVertexAttribArray(0);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        457 +
                                                GL.glDisableVertexAttribArray(1);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        458 +
                                                GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        459 +
                                                gl_area.queue_draw()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        460 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        461 +
                                            def on_tick(self, widget, frame_clock):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        462 +
                                                self.request_next_frame()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        463 +
                                                return GLib.SOURCE_CONTINUE
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            464  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            465  
                                            class WFWindowList(panorama_panel.Applet):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            466  
                                                name = _("Wayfire window list")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -352,9 +517,14 @@ class WFWindowList(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            517  
                                                    self.add_controller(self.drop_target)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            518  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            519  
                                                    # Make a Wayfire socket for workspace handling
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        520 +
                                                self.live_preview_tooltips = False
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            521  
                                                    try:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            522  
                                                        import wayfire
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        523 +
                                                    from wayfire.core.template import get_msg_template
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            524  
                                                        self.wf_socket = wayfire.WayfireSocket()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        525 +
                                                    self.get_msg_template = get_msg_template
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        526 +
                                                    if "live_previews/request_stream" in self.wf_socket.list_methods():
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        527 +
                                                        self.live_preview_tooltips = True
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            528  
                                                        self.wf_socket.watch(["view-workspace-changed", "wset-workspace-changed"])
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            529  
                                                        fd = self.wf_socket.client.fileno()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            530  
                                                        GLib.io_add_watch(GLib.IOChannel.unix_new(fd), GLib.IO_IN, self.on_wf_event, priority=GLib.PRIORITY_HIGH)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -479,7 +649,11 @@ class WFWindowList(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            649  
                                                            self.my_output = monitor.output_proxy
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            650  
                                                    # End hack
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            651  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        652 +
                                                self.output = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        653 +
                                                self.wl_shm = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            654  
                                                    self.manager = None
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        655 +
                                                self.screencopy_manager = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        656 +
                                                self.live_preview_output_name = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            657  
                                                    self.registry = self.display.get_registry()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            658  
                                                    self.registry.dispatcher["global"] = self.on_global
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            659  
                                                    self.display.roundtrip()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -487,6 +661,8 @@ class WFWindowList(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            661  
                                                        print("Could not load wf-window-list. Is foreign-toplevel protocol advertised by the compositor?")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            662  
                                                        print("(Wayfire requires enabling foreign-toplevel plugin)")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            663  
                                                        return
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        664 +
                                                if self.screencopy_manager is None:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        665 +
                                                    print("Protocol zwlr_screencopy_manager_v1 not found, live (minimized) window previews will not work!")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            666  
                                                    self.manager.dispatcher["toplevel"] = self.on_new_toplevel
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            667  
                                                    self.manager.dispatcher["finished"] = lambda *a: print("Toplevel manager finished")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            668  
                                                    self.display.roundtrip()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -501,13 +677,39 @@ class WFWindowList(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            677  
                                                        self.display.dispatch(queue=self.event_queue)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            678  
                                                    return True
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            679  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        680 +
                                            def set_live_preview_output(self, output):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        681 +
                                                self.output = output
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        682 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        683 +
                                            def get_live_preview_output(self):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        684 +
                                                return self.output
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        685 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        686 +
                                            def set_live_preview_output_name(self, name):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        687 +
                                                self.live_preview_output_name = name
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        688 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        689 +
                                            def get_live_preview_output_name(self):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        690 +
                                                return self.live_preview_output_name
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        691 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        692 +
                                            def wl_output_handle_name(self, output, name):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        693 +
                                                if name != self.get_live_preview_output_name():
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        694 +
                                                    output.release()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        695 +
                                                    output.destroy()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        696 +
                                                    return
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        697 +
                                                self.set_live_preview_output(output)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        698 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            699  
                                                def on_global(self, registry, name, interface, version):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            700  
                                                    if interface == "zwlr_foreign_toplevel_manager_v1":
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            701  
                                                        self.print_log("Interface registered")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            702  
                                                        self.manager = registry.bind(name, ZwlrForeignToplevelManagerV1, version)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        703 +
                                                elif interface == "wl_output":
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        704 +
                                                    if self.live_preview_output_name is None:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        705 +
                                                        return
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        706 +
                                                    wl_output = registry.bind(name, WlOutput, version)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        707 +
                                                    wl_output.dispatcher["name"] = self.wl_output_handle_name
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            708  
                                                    elif interface == "wl_seat":
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            709  
                                                        self.print_log("Seat found")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            710  
                                                        self.seat = registry.bind(name, WlSeat, version)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        711 +
                                                elif interface == "wl_shm":
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        712 +
                                                    self.wl_shm = registry.bind(name, WlShm, version)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            713  
                                                    elif interface == "wl_compositor":
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            714  
                                                        self.compositor = registry.bind(name, WlCompositor, version)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            715  
                                                        wl_surface_ptr = gtk.gdk_wayland_surface_get_wl_surface(
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -515,6 +717,8 @@ class WFWindowList(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            717  
                                                                    self.get_root().get_native().get_surface().__gpointer__, None)))
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            718  
                                                        self.wl_surface = WlSurface()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            719  
                                                        self.wl_surface._ptr = wl_surface_ptr
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        720 +
                                                elif interface == "zwlr_screencopy_manager_v1":
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        721 +
                                                    self.screencopy_manager = registry.bind(name, ZwlrScreencopyManagerV1, version)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            722  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            723  
                                                def on_new_toplevel(self, manager: ZwlrForeignToplevelManagerV1,
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            724  
                                                                     handle: ZwlrForeignToplevelHandleV1):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -524,9 +728,10 @@ class WFWindowList(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            728  
                                                    handle.dispatcher["output_leave"] = self.on_output_left
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            729  
                                                    handle.dispatcher["state"] = self.on_state_changed
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            730  
                                                    handle.dispatcher["closed"] = self.on_closed
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        731 +
                                                self.display.roundtrip()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            732  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            733  
                                                def on_output_entered(self, handle, output):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        529 -
                                                button = WindowButton(handle, handle.title)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        734 +
                                                button = WindowButton(handle, handle.title, self)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            735  
                                                    button.icon.set_pixel_size(self.icon_size)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            736  
                                                    button.output = None
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            737  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -553,7 +758,8 @@ class WFWindowList(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            758  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            759  
                                                def set_title(self, button, title):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            760  
                                                    button.window_title = title
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        556 -
                                                button.set_tooltip_text(title)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        761 +
                                                if not self.live_preview_tooltips:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        762 +
                                                    button.set_tooltip_text(title)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            763  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            764  
                                                def on_title_changed(self, handle, title):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            765  
                                                    handle.title = title
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -572,12 +778,13 @@ class WFWindowList(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            778  
                                                def on_button_click(self, button: WindowButton):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            779  
                                                    # Set a rectangle for animation
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            780  
                                                    button.window_id.set_rectangle(self.wl_surface, *get_widget_rect(button))
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        575 -
                                                if button.window_state.focused:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        576 -
                                                    # Already pressed in, so minimise the focused window
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        577 -
                                                    button.window_id.set_minimized()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        578 -
                                                else:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        579 -
                                                    button.window_id.unset_minimized()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        781 +
                                                if button.window_state.minimised:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            782  
                                                        button.window_id.activate(self.seat)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        783 +
                                                else:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        784 +
                                                    if button.window_state.focused:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        785 +
                                                        button.window_id.set_minimized()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        786 +
                                                    else:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        787 +
                                                        button.window_id.activate(self.seat)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            788  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            789  
                                                def on_state_changed(self, handle, states):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            790  
                                                    if handle in self.toplevel_buttons:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -592,6 +799,7 @@ class WFWindowList(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            799  
                                                    self.set_all_rectangles()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            800  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            801  
                                                def set_app_id(self, button, app_id):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        802 +
                                                button.app_id = app_id
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            803  
                                                    button.set_icon_from_app_id(app_id)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            804  
                                                    app_ids = app_id.split()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            805  
                                                    for app_id in app_ids: