-rw-r--r-- wayland.py

---

 """
 Wayland-specific configuration
 """
 
 import asyncio
 import os
 import subprocess
 
 from libqtile import hook, qtile
 from libqtile.backend.wayland import InputConfig
 from libqtile.backend.wayland.xdgwindow import XdgWindow
 from libqtile.backend.wayland.xwindow import XWindow
 from libqtile.backend.wayland.layer import LayerStatic
 from libqtile.lazy import lazy
 
 IS_XEPHYR = int(os.environ.get("QTILE_XEPHYR", 0))
 mod = "mod1" if IS_XEPHYR else "mod4"
 
 term = "footclient"
 keys_backend = []
 
 
 # Keys to change VT
 keys_backend.extend(
     [
         ([mod], "F1", lazy.core.change_vt(1), "Change to VT 1"),
         ([mod], "F2", lazy.core.change_vt(2), "Change to VT 2"),
         ([mod], "F3", lazy.core.change_vt(3), "Change to VT 3"),
         ([mod], "F4", lazy.core.change_vt(4), "Change to VT 4"),
     ]
 )
 
 # Inputs configuration
 wl_input_rules = {
     "type:keyboard": InputConfig(
         kb_options="caps:swapescape,altwin:swap_alt_win",
         kb_layout="gb",
         kb_repeat_rate=50,
         kb_repeat_delay=250,
     ),
     # All touchpads
     "type:touchpad": InputConfig(drag=True, tap=True, dwt=False, pointer_accel=0.3),
     # Roccat Kiro mouse
     "7805:11320:ROCCAT ROCCAT Kiro Mouse": InputConfig(
         #left_handed=True,
         pointer_accel=-1.0,
     ),
     # Anker mouse
     "7119:5:USB Optical Mouse": InputConfig(pointer_accel=-1.0),
 }
 
 
 # Shadows configuration
 # wl_shadows = {
 #    "radius": 12,
 #    "color": "#05001088",
 #    "offset": (-6, -6),
 # }
 wl_shadows = {
     "radius": 5,
     "color": "#ff000044",
     "offset": (0, 0),
 }
 
 
 @hook.subscribe.client_new
 def _(win):
     # Auto-float some windows
     if isinstance(win, XdgWindow):
         max_width = win.surface.toplevel._ptr.current.max_width
         if 0 < max_width < 1920:
             win.floating = True
     elif isinstance(win, XWindow):
         if hints := win.surface.size_hints:
             max_width = hints.max_width
             if 0 < max_width < 1920:
                 win.floating = True
 
 
 @hook.subscribe.client_managed
 async def _(win):
     # Some other miscellaneous rules
     if win.name == "Firefox — Sharing Indicator":
         win.place(win.x + win.borderwidth, 0, win.width, win.height, 0, None)
         return
 
     wm_class = win.get_wm_class() or []
     if win.name == "Navigator" and "libreoffice-startcenter" in wm_class:
         x = qtile.current_screen.x
         win.place(x, 240, 450, 600, win.borderwidth, win.bordercolor)
         return
 
     if "mpv" in wm_class:
         # Resizing mpv if it's sized itself too big to fit on screen
         sw = qtile.current_screen.width
         sh = qtile.current_screen.height
         x = y = w = h = None
         if win.height > sh:
             h = sh
             y = qtile.current_screen.y
         if win.width > sw:
             w = sw
             x = qtile.current_screen.x
         if w is not None or h is not None:
             if h is None:
                 h = win.height
                 y = win.y
             else:
                 w = win.width
                 x = win.x
             bw = win.borderwidth
             win.place(x - bw, y - bw, w + 2 * bw, h + 2 * bw, 0, None)
         return
 
 
 @hook.subscribe.startup_once
 async def _():
     # Run a startup script
     HOME = os.path.expanduser("~")
     p = subprocess.Popen(f"{HOME}/.config/qtile/startup.sh")
     hook.subscribe.shutdown(p.terminate)
 
 
 ## I don't use this monitor, but keep this around for testing
 #
 #@hook.subscribe.screen_change
 #def _(*_):
 #    # Temporary hacky fix for the dell monitor on my desk which for some mysterious
 #    # reason doesn't advertise that it supports any HD mode. Qtile does support setting
 #    # custom modes via the protocol, but neither kanshi nor wdisplays do. So instead,
 #    # I'll detect if that monitor is present and set the desired custom mode here.
 #    for output in qtile.core.outputs:
 #        wlr_output = output.wlr_output
 #        # Not only does this monitor not report modes correctly, it ALSO doesn't report
 #        # a make or model.
 #        if wlr_output.make == wlr_output.model == "<Unknown>":
 #            if wlr_output.current_mode.width == 1024:
 #                break
 #    else:
 #        return
 #
 #    wlr_output.set_custom_mode(1920, 1080, 0)
 #    # Lastly, while reconfigure_screens will be fired right after this hook, as it
 #    # gets subscribed to this hook right after the config is loaded, the backend doesn't
 #    # get a chance to actually apply the mode, so let's flush it.
 #    qtile.core.flush()
 
 
 ## UNNECESSARY? The backend should update the output with reconfigre_screens=True
 #
 #if IS_XEPHYR:
 #    # To adapt to whatever window size it was given
 #    @hook.subscribe.startup_once
 #    async def _():
 #        await asyncio.sleep(0.5)
 #        qtile.reconfigure_screens()