[WIP] regenerate panels when outputs change

main.py

@@ -30,8 +30,8 @@ import locale

                                
                                
                                
                            
                                
                                    
                                        
                                            30  
                                            from itertools import accumulate, chain
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            31  
                                            from pathlib import Path
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            32  
                                            import ruamel.yaml as yaml
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        33 -
                                        from pywayland.client import Display
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        34 -
                                        from pywayland.protocol.wayland import WlRegistry, WlSeat, WlSurface, WlCompositor
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        33 +
                                        from pywayland.client import Display, EventQueue
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        34 +
                                        from pywayland.protocol.wayland import WlRegistry, WlSeat, WlSurface, WlCompositor, WlOutput
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            35  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            36  
                                            faulthandler.enable()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            37  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -47,6 +47,16 @@ gi.require_version("Gtk4LayerShell", "1.0")

                                
                                
                                
                            
                                
                                    
                                        
                                            47  
                                            from gi.repository import Gtk, GLib, Gtk4LayerShell, Gdk, Gio, GObject
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            48  
                                            from gi.events import GLibEventLoopPolicy
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            49  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        50 +
                                        import ctypes
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        51 +
                                        from cffi import FFI
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        52 +
                                        ffi = FFI()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        53 +
                                        ffi.cdef("""
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        54 +
                                        void * gdk_wayland_display_get_wl_display (void * display);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        55 +
                                        void * gdk_wayland_surface_get_wl_surface (void * surface);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        56 +
                                        void * gdk_wayland_monitor_get_wl_output (void * monitor);
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        57 +
                                        """)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        58 +
                                        gtk = ffi.dlopen("libgtk-4.so.1")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        59 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            60  
                                            sys.path.insert(0, str((Path(__file__).parent / "shared").resolve()))
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            61  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            62  
                                            locale.bindtextdomain("panorama-panel", "locale")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -594,6 +604,8 @@ class PanoramaPanel(Gtk.Application):

                                
                                
                                
                            
                                
                                    
                                        
                                            604  
                                                    self.manager_window = None
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            605  
                                                    self.edit_mode = False
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            606  
                                                    self.drags = {}
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        607 +
                                                self.wl_output_ids = set()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        608 +
                                                self.started = False
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            609  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            610  
                                                    self.add_main_option(
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            611  
                                                        "trigger",
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -604,20 +616,42 @@ class PanoramaPanel(Gtk.Application):

                                
                                
                                
                            
                                
                                    
                                        
                                            616  
                                                        _("NAME")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            617  
                                                    )
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            618  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        607 -
                                            def do_startup(self):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        608 -
                                                Gtk.Application.do_startup(self)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        619 +
                                            def receive_output_name(self, output: WlOutput, name: str):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        620 +
                                                output.name = name
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        621 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        622 +
                                            def on_global(self, registry, name, interface, version):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        623 +
                                                if interface == "wl_output":
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        624 +
                                                    output = registry.bind(name, WlOutput, version)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        625 +
                                                    print(f"global {name} {interface} {version}")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        626 +
                                                    output.global_name = name
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        627 +
                                                    output.dispatcher["name"] = self.receive_output_name
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        628 +
                                                    output.name = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        629 +
                                                    while not output.name:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        630 +
                                                        self.wl_display.dispatch(block=True)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        631 +
                                                    print(output.name)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        632 +
                                                    if not output.name.startswith("live-preview"):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        633 +
                                                        self.wl_output_ids.add(output.global_name)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        634 +
                                                        self.generate_panels()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        635 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        636 +
                                                    print(f"Monitor {name} ({interface}) connected", file=sys.stderr)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        637 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        638 +
                                            def on_global_remove(self, registry, name):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        639 +
                                                print("global removed")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        640 +
                                                if name in self.wl_output_ids:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        641 +
                                                    print(f"Monitor {name} disconnected", file=sys.stderr)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        642 +
                                                    self.generate_panels()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        643 +
                                                    self.wl_output_ids.discard(name)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        644 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        645 +
                                            def generate_panels(self):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        646 +
                                                print("Generating panels...", file=sys.stderr)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        647 +
                                                self.exit_all_applets()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        648 +
                                                for panel in self.panels:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        649 +
                                                    panel.destroy()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        650 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            651  
                                                    for i, monitor in enumerate(self.monitors):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            652  
                                                        geometry = monitor.get_geometry()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            653  
                                                        print(f"Monitor {i}: {geometry.width}x{geometry.height} at {geometry.x},{geometry.y}")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            654  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        613 -
                                                all_applets = list(chain.from_iterable(load_packages_from_dir(d) for d in get_applet_directories()))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        614 -
                                                print("Applets:")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        615 -
                                                subclasses = get_all_subclasses(panorama_panel.Applet)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        616 -
                                                for subclass in subclasses:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        617 -
                                                    if subclass.__name__ in self.applets_by_name:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        618 -
                                                        print(f"Name conflict for applet {subclass.__name__}. Only one will be loaded.", file=sys.stderr)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        619 -
                                                    self.applets_by_name[subclass.__name__] = subclass
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        620 -
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            655  
                                                    with open(get_config_file(), "r") as config_file:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            656  
                                                        yaml_loader = yaml.YAML(typ="rt")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            657  
                                                        yaml_file = yaml_loader.load(config_file)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -655,6 +689,41 @@ class PanoramaPanel(Gtk.Application):

                                
                                
                                
                            
                                
                                    
                                        
                                            689  
                                                            panel.present()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            690  
                                                            panel.realize()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            691  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        692 +
                                            def prepare(self):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        693 +
                                                self.release()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        694 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        695 +
                                                print("started", file=sys.stderr)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        696 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        697 +
                                            def do_startup(self):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        698 +
                                                Gtk.Application.do_startup(self)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        699 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        700 +
                                                ctypes.pythonapi.PyCapsule_GetPointer.restype = ctypes.c_void_p
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        701 +
                                                ctypes.pythonapi.PyCapsule_GetPointer.argtypes = (ctypes.py_object,)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        702 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        703 +
                                                all_applets = list(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        704 +
                                                    chain.from_iterable(load_packages_from_dir(d) for d in get_applet_directories()))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        705 +
                                                print("Applets:")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        706 +
                                                subclasses = get_all_subclasses(panorama_panel.Applet)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        707 +
                                                for subclass in subclasses:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        708 +
                                                    if subclass.__name__ in self.applets_by_name:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        709 +
                                                        print(f"Name conflict for applet {subclass.__name__}. Only one will be loaded.",
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        710 +
                                                              file=sys.stderr)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        711 +
                                                    self.applets_by_name[subclass.__name__] = subclass
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        712 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        713 +
                                                self.wl_display = Display()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        714 +
                                                wl_display_ptr = gtk.gdk_wayland_display_get_wl_display(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        715 +
                                                        ffi.cast("void *", ctypes.pythonapi.PyCapsule_GetPointer(self.display.__gpointer__, None)))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        716 +
                                                self.wl_display._ptr = wl_display_ptr
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        717 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        718 +
                                                # Intentionally commented: the display is already connected by GTK
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        719 +
                                                # self.display.connect()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        720 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        721 +
                                                self.registry = self.wl_display.get_registry()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        722 +
                                                self.registry.dispatcher["global"] = self.on_global
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        723 +
                                                self.registry.dispatcher["global_remove"] = self.on_global_remove
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        724 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        725 +
                                                self.hold()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        726 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            727  
                                                def do_activate(self):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            728  
                                                    Gio.Application.do_activate(self)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            729  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -688,8 +757,7 @@ class PanoramaPanel(Gtk.Application):

                                
                                
                                
                            
                                
                                    
                                        
                                            757  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            758  
                                                        yaml_writer.dump(data, config_file)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            759  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        691 -
                                            def do_shutdown(self):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        692 -
                                                print("Shutting down")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        760 +
                                            def exit_all_applets(self):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            761  
                                                    for panel in self.panels:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            762  
                                                        for area in (panel.left_area, panel.centre_area, panel.right_area):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            763  
                                                            applet = area.get_first_child()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -697,6 +765,10 @@ class PanoramaPanel(Gtk.Application):

                                
                                
                                
                            
                                
                                    
                                        
                                            765  
                                                                applet.shutdown(self)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            766  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            767  
                                                                applet = applet.get_next_sibling()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        768 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        769 +
                                            def do_shutdown(self):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        770 +
                                                print("Shutting down")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        771 +
                                                self.exit_all_applets()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            772  
                                                    Gtk.Application.do_shutdown(self)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            773  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            774  
                                                def do_command_line(self, command_line: Gio.ApplicationCommandLine):