Bump version to 0.1.10-1

Uhh, apparently cargo doesn't like four-component versions.

.github/dependabot.yml

@@ -1,22 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "cargo"
-    directory: "/"
-    schedule:
-      interval: "daily"
-    groups:
-      smithay:
-        patterns:
-          - "smithay"
-          - "smithay-drm-extras"
-      rust-dependencies:
-        update-types:
-          - "minor"
-          - "patch"
-
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "daily"
-    ignore:
-      - dependency-name: "Andrew-Chen-Wang/github-wiki-action"

.github/workflows/ci.yml

@@ -9,8 +9,6 @@ on:
 
 env:
   RUN_SLOW_TESTS: 1
-  DEPS_APT: curl gcc clang libudev-dev libgbm-dev libxkbcommon-dev libegl1-mesa-dev libwayland-dev libinput-dev libdbus-1-dev libsystemd-dev libseat-dev libpipewire-0.3-dev libpango1.0-dev libdisplay-info-dev
-  DEPS_DNF: cargo gcc clang libudev-devel libgbm-devel libxkbcommon-devel wayland-devel libinput-devel dbus-devel systemd-devel libseat-devel pipewire-devel pango-devel cairo-gobject-devel libdisplay-info-devel
 
 jobs:
   build:
@@ -25,7 +23,8 @@ jobs:
             release-flag: '--release'
 
     name: test - ${{ matrix.configuration }}
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
+    container: ubuntu:23.10
 
     steps:
       - uses: actions/checkout@v4
@@ -34,8 +33,8 @@ jobs:
 
       - name: Install dependencies
         run: |
-          sudo apt-get update -y
+          apt-get update -y
-          sudo apt-get install -y ${{ env.DEPS_APT }}
+          apt-get install -y curl gcc clang libudev-dev libgbm-dev libxkbcommon-dev libegl1-mesa-dev libwayland-dev libinput-dev libdbus-1-dev libsystemd-dev libseat-dev libpipewire-0.3-dev libpango1.0-dev libdisplay-info-dev
 
       - uses: dtolnay/rust-toolchain@stable
 
@@ -64,53 +63,19 @@ jobs:
       - name: Build (with profiling)
         run: cargo build ${{ matrix.release-flag }} --features profile-with-tracy
 
-      - name: Build tests
+      - name: Build Tests
         run: cargo test --no-run --all --exclude niri-visual-tests ${{ matrix.release-flag }}
 
       - name: Test
         run: cargo test --all --exclude niri-visual-tests ${{ matrix.release-flag }} -- --nocapture
 
-  # Job that runs randomized tests for a longer period of time.
-  randomized-tests:
-    strategy:
-      fail-fast: false
-
-    name: randomized tests
-    runs-on: ubuntu-24.04
-
-    env:
-      RUST_BACKTRACE: 1
-      PROPTEST_CASES: 200000
-      PROPTEST_MAX_LOCAL_REJECTS: 200000
-      PROPTEST_MAX_GLOBAL_REJECTS: 200000
-      PROPTEST_MAX_SHRINK_ITERS: 200000
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          show-progress: false
-
-      - name: Install dependencies
-        run: |
-          sudo apt-get update -y
-          sudo apt-get install -y ${{ env.DEPS_APT }}
-
-      - uses: dtolnay/rust-toolchain@stable
-
-      - uses: Swatinem/rust-cache@v2
-
-      - name: Build tests
-        run: cargo test --no-run --all --exclude niri-visual-tests --release
-
-      - name: Test
-        run: cargo test --all --exclude niri-visual-tests --release
-
   visual-tests:
     strategy:
       fail-fast: false
 
     name: visual tests
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
+    container: ubuntu:23.10
 
     steps:
       - uses: actions/checkout@v4
@@ -119,8 +84,8 @@ jobs:
 
       - name: Install dependencies
         run: |
-          sudo apt-get update -y
+          apt-get update -y
-          sudo apt-get install -y ${{ env.DEPS_APT }} libadwaita-1-dev
+          apt-get install -y curl gcc clang libudev-dev libgbm-dev libxkbcommon-dev libegl1-mesa-dev libwayland-dev libinput-dev libdbus-1-dev libsystemd-dev libseat-dev libpipewire-0.3-dev libpango1.0-dev libadwaita-1-dev libdisplay-info-dev
 
       - uses: dtolnay/rust-toolchain@stable
 
@@ -133,8 +98,9 @@ jobs:
     strategy:
       fail-fast: false
 
-    name: msrv
+    name: 'msrv - 1.77.0'
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
+    container: ubuntu:23.10
 
     steps:
       - uses: actions/checkout@v4
@@ -143,10 +109,10 @@ jobs:
 
       - name: Install dependencies
         run: |
-          sudo apt-get update -y
+          apt-get update -y
-          sudo apt-get install -y ${{ env.DEPS_APT }} libadwaita-1-dev
+          apt-get install -y curl gcc clang libudev-dev libgbm-dev libxkbcommon-dev libegl1-mesa-dev libwayland-dev libinput-dev libdbus-1-dev libsystemd-dev libseat-dev libpipewire-0.3-dev libpango1.0-dev libadwaita-1-dev libdisplay-info-dev
 
-      - uses: dtolnay/rust-toolchain@1.80.1
+      - uses: dtolnay/rust-toolchain@1.77.0
 
       - uses: Swatinem/rust-cache@v2
 
@@ -157,7 +123,8 @@ jobs:
       fail-fast: false
 
     name: clippy
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
+    container: ubuntu:23.10
 
     steps:
       - uses: actions/checkout@v4
@@ -166,8 +133,8 @@ jobs:
 
       - name: Install dependencies
         run: |
-          sudo apt-get update -y
+          apt-get update -y
-          sudo apt-get install -y ${{ env.DEPS_APT }} libadwaita-1-dev
+          apt-get install -y curl gcc clang libudev-dev libgbm-dev libxkbcommon-dev libegl1-mesa-dev libwayland-dev libinput-dev libdbus-1-dev libsystemd-dev libseat-dev libpipewire-0.3-dev libpango1.0-dev libadwaita-1-dev libdisplay-info-dev
 
       - uses: dtolnay/rust-toolchain@stable
         with:
@@ -179,7 +146,7 @@ jobs:
         run: cargo clippy --all --all-targets
 
   rustfmt:
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
 
     steps:
       - uses: actions/checkout@v4
@@ -194,8 +161,8 @@ jobs:
         run: cargo fmt --all -- --check
 
   fedora:
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
-    container: fedora:41
+    container: fedora:39
 
     steps:
       - uses: actions/checkout@v4
@@ -205,13 +172,13 @@ jobs:
       - name: Install dependencies
         run: |
           sudo dnf update -y
-          sudo dnf install -y ${{ env.DEPS_DNF }} libadwaita-devel
+          sudo dnf install -y cargo gcc libudev-devel libgbm-devel libxkbcommon-devel wayland-devel libinput-devel dbus-devel systemd-devel libseat-devel pipewire-devel pango-devel cairo-gobject-devel clang libadwaita-devel libdisplay-info-devel
 
       - uses: Swatinem/rust-cache@v2
       - run: cargo build --all
 
   nix:
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v4
         with:
@@ -233,7 +200,7 @@ jobs:
     needs: build
     permissions:
       contents: write
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v4
         with:
@@ -245,7 +212,7 @@ jobs:
     needs: build
     permissions:
       contents: write
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v4
         with:

.github/workflows/release.yml

@@ -1,63 +0,0 @@
-name: Prepare release
-
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: 'Public version'
-        required: true
-
-concurrency:
-  group: ${{ github.workflow }}
-  cancel-in-progress: true
-
-env:
-  RUN_SLOW_TESTS: 1
-
-jobs:
-  prepare-release:
-    runs-on: ubuntu-24.04
-
-    permissions:
-      contents: write
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          show-progress: false
-
-      - name: Check for unreplaced "Since:" in the wiki
-        run: |
-          if grep --recursive 'Since: next release' wiki; then
-            exit 1
-          fi
-
-      - name: Install dependencies
-        run: |
-          sudo apt-get update -y
-          sudo apt-get install -y curl gcc clang libudev-dev libgbm-dev libxkbcommon-dev libegl1-mesa-dev libwayland-dev libinput-dev libdbus-1-dev libsystemd-dev libseat-dev libpipewire-0.3-dev libpango1.0-dev libdisplay-info-dev libadwaita-1-dev
-
-      - uses: dtolnay/rust-toolchain@stable
-
-      - name: Create vendored dependencies archive
-        run: |
-          mkdir .cargo
-          cargo vendor --locked > .cargo/config.toml
-          tar cJf niri-${{ github.event.inputs.version }}-vendored-dependencies.tar.xz vendor/
-
-      - name: Build
-        run: cargo build --all --frozen --release
-
-      - name: Build tests
-        run: cargo test --no-run --all --frozen --release
-
-      - name: Test
-        run: cargo test --all --frozen --release -- --nocapture
-
-      - name: Draft release
-        uses: softprops/action-gh-release@v2
-        with:
-          draft: true
-          tag_name: v${{ github.event.inputs.version }}
-          files: niri-${{ github.event.inputs.version }}-vendored-dependencies.tar.xz
-          fail_on_unmatched_files: true

Cargo.toml

@@ -1,38 +1,32 @@
 [workspace]
-members = [
+members = ["niri-visual-tests"]
-    "niri-config",
-    "niri-ipc",
-    "niri-visual-tests",
-]
 
 [workspace.package]
-version = "25.2.0"
+version = "0.1.10-1"
 description = "A scrollable-tiling Wayland compositor"
 authors = ["Ivan Molodetskikh <yalterz@gmail.com>"]
 license = "GPL-3.0-or-later"
 edition = "2021"
 repository = "https://github.com/YaLTeR/niri"
-rust-version = "1.80.1"
+rust-version = "1.77"
 
 [workspace.dependencies]
-anyhow = "1.0.96"
+anyhow = "1.0.93"
-bitflags = "2.8.0"
+bitflags = "2.6.0"
-clap = { version = "4.5.30", features = ["derive"] }
+clap = { version = "4.5.20", features = ["derive"] }
-insta = "1.42.1"
+k9 = "0.12.0"
-serde = { version = "1.0.218", features = ["derive"] }
+serde = { version = "1.0.214", features = ["derive"] }
-serde_json = "1.0.139"
+serde_json = "1.0.132"
-tracing = { version = "0.1.41", features = ["max_level_trace", "release_max_level_debug"] }
+tracing = { version = "0.1.40", features = ["max_level_trace", "release_max_level_debug"] }
-tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
+tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
-tracy-client = { version = "0.18.0", default-features = false }
+tracy-client = { version = "0.17.4", default-features = false }
 
 [workspace.dependencies.smithay]
-# version = "0.4.1"
 git = "https://github.com/Smithay/smithay.git"
 # path = "../smithay"
 default-features = false
 
 [workspace.dependencies.smithay-drm-extras]
-# version = "0.1.0"
 git = "https://github.com/Smithay/smithay.git"
 # path = "../smithay/smithay-drm-extras"
 
@@ -53,44 +47,45 @@ keywords = ["wayland", "compositor", "tiling", "smithay", "wm"]
 anyhow.workspace = true
 arrayvec = "0.7.6"
 async-channel = "2.3.1"
-async-io = { version = "2.4.0", optional = true }
+async-io = { version = "1.13.0", optional = true }
 atomic = "0.6.0"
 bitflags.workspace = true
-bytemuck = { version = "1.21.0", features = ["derive"] }
+bytemuck = { version = "1.19.0", features = ["derive"] }
-calloop = { version = "0.14.2", features = ["executor", "futures-io"] }
+calloop = { version = "0.14.1", features = ["executor", "futures-io"] }
 clap = { workspace = true, features = ["string"] }
-directories = "6.0.0"
+directories = "5.0.1"
 drm-ffi = "0.9.0"
-fastrand = "2.3.0"
+fastrand = "2.2.0"
 futures-util = { version = "0.3.31", default-features = false, features = ["std", "io"] }
 git-version = "0.3.9"
-glam = "0.30.0"
+glam = "0.29.2"
 input = { version = "0.9.1", features = ["libinput_1_21"] }
 keyframe = { version = "1.1.1", default-features = false }
-libc = "0.2.169"
+libc = "0.2.162"
-libdisplay-info = "0.2.2"
+libdisplay-info = "0.1.0"
-log = { version = "0.4.25", features = ["max_level_trace", "release_max_level_debug"] }
+log = { version = "0.4.22", features = ["max_level_trace", "release_max_level_debug"] }
-niri-config = { version = "25.2.0", path = "niri-config" }
+niri-config = { version = "0.1.10-1", path = "niri-config" }
-niri-ipc = { version = "25.2.0", path = "niri-ipc", features = ["clap"] }
+niri-ipc = { version = "0.1.10-1", path = "niri-ipc", features = ["clap"] }
-ordered-float = "5.0.0"
+notify-rust = { version = "~4.10.0", optional = true }
-pango = { version = "0.20.9", features = ["v1_44"] }
+ordered-float = "4.5.0"
-pangocairo = "0.20.7"
+pango = { version = "0.20.4", features = ["v1_44"] }
+pangocairo = "0.20.4"
 pipewire = { git = "https://gitlab.freedesktop.org/pipewire/pipewire-rs.git", optional = true, features = ["v0_3_33"] }
-png = "0.17.16"
+png = "0.17.14"
-portable-atomic = { version = "1.10.0", default-features = false, features = ["float"] }
+portable-atomic = { version = "1.9.0", default-features = false, features = ["float"] }
 profiling = "1.0.16"
-sd-notify = "0.4.5"
+sd-notify = "0.4.3"
 serde.workspace = true
 serde_json.workspace = true
 smithay-drm-extras.workspace = true
 tracing-subscriber.workspace = true
 tracing.workspace = true
 tracy-client.workspace = true
-url = { version = "2.5.4", optional = true }
+url = { version = "2.5.3", optional = true }
-wayland-backend = "0.3.8"
+wayland-backend = "0.3.7"
-wayland-scanner = "0.31.6"
+wayland-scanner = "0.31.5"
 xcursor = "0.3.8"
-zbus = { version = "5.5.0", optional = true }
+zbus = { version = "~3.15.2", optional = true }
 
 [dependencies.smithay]
 workspace = true
@@ -112,18 +107,15 @@ features = [
 
 [dev-dependencies]
 approx = "0.5.1"
-calloop-wayland-source = "0.4.0"
+k9.workspace = true
-insta.workspace = true
+proptest = "1.5.0"
-proptest = "1.6.0"
+proptest-derive = { version = "0.5.0", features = ["boxed_union"] }
-proptest-derive = { version = "0.5.1", features = ["boxed_union"] }
+xshell = "0.2.6"
-rayon = "1.10.0"
-wayland-client = "0.31.8"
-xshell = "0.2.7"
 
 [features]
 default = ["dbus", "systemd", "xdp-gnome-screencast"]
 # Enables D-Bus support (serve various freedesktop and GNOME interfaces, power button handling).
-dbus = ["dep:zbus", "dep:async-io", "dep:url"]
+dbus = ["zbus", "async-io", "notify-rust", "url"]
 # Enables systemd integration (global environment, apps in transient scopes).
 systemd = ["dbus"]
 # Enables screencasting support through xdg-desktop-portal-gnome.
@@ -146,12 +138,8 @@ lto = "thin"
 # knuffel with chomsky generates a metric ton of debuginfo.
 debug = false
 
-[profile.dev.package]
-insta.opt-level = 3
-similar.opt-level = 3
-
 [package.metadata.generate-rpm]
-version = "25.02"
+version = "0.1.10.1"
 assets = [
     { source = "target/release/niri", dest = "/usr/bin/", mode = "755" },
     { source = "resources/niri-session", dest = "/usr/bin/", mode = "755" },

README.md

@@ -1,7 +1,7 @@
 <h1 align="center">niri</h1>
 <p align="center">A scrollable-tiling Wayland compositor.</p>
 <p align="center">
-    <a href="https://matrix.to/#/#niri:matrix.org"><img alt="Matrix" src="https://img.shields.io/badge/matrix-%23niri-blue?logo=matrix"></a>
+    <a href="https://matrix.to/#/#niri:matrix.org"><img alt="Matrix" src="https://img.shields.io/matrix/niri%3Amatrix.org?logo=matrix&label=matrix"></a>
     <a href="https://github.com/YaLTeR/niri/blob/main/LICENSE"><img alt="GitHub License" src="https://img.shields.io/github/license/YaLTeR/niri"></a>
     <a href="https://github.com/YaLTeR/niri/releases"><img alt="GitHub Release" src="https://img.shields.io/github/v/release/YaLTeR/niri?logo=github"></a>
 </p>
@@ -10,7 +10,7 @@
     <a href="https://github.com/YaLTeR/niri/wiki/Getting-Started">Getting Started</a> | <a href="https://github.com/YaLTeR/niri/wiki/Configuration:-Overview">Configuration</a> | <a href="https://github.com/YaLTeR/niri/discussions/325">Setup&nbsp;Showcase</a>
 </p>
 
-![niri with a few windows open](https://github.com/user-attachments/assets/d142e57d-a25d-4ddb-ab46-311417458211)
+![](https://github.com/YaLTeR/niri/assets/1794388/52c799a1-77ec-455f-b4aa-f3236a144964)
 
 ## About
 
@@ -28,7 +28,7 @@ When a monitor disconnects, its workspaces will move to another monitor, but upo
 
 ## Features
 
-- Built from the ground up for scrollable tiling
+- Scrollable tiling
 - Dynamic workspaces like in GNOME
 - Built-in screenshot UI
 - Monitor and window screencasting through xdg-desktop-portal-gnome
@@ -45,35 +45,10 @@ https://github.com/YaLTeR/niri/assets/1794388/bce834b0-f205-434e-a027-b373495f97
 
 ## Status
 
-Niri is stable for day-to-day use and does most things expected of a Wayland compositor.
+A lot of the essential functionality is implemented, plus some goodies on top.
-Many people are daily-driving niri, and are happy to help in our [Matrix channel].
+Feel free to give niri a try: follow the instructions on the [Getting Started](https://github.com/YaLTeR/niri/wiki/Getting-Started) wiki page.
-
-Give it a try!
-Follow the instructions on the [Getting Started](https://github.com/YaLTeR/niri/wiki/Getting-Started) wiki page.
 Have your [waybar]s and [fuzzel]s ready: niri is not a complete desktop environment.
 
-Here are some points you may have questions about:
-
-- **Multi-monitor**: yes, a core part of the design from the very start. Mixed DPI works.
-- **Fractional scaling**: yes, plus all niri UI stays pixel-perfect.
-- **NVIDIA**: seems to work fine.
-- **Floating windows**: yes, starting from niri 25.01.
-- **Input devices**: niri supports tablets, touchpads, and touchscreens.
-You can map the tablet to a specific monitor, or use [OpenTabletDriver].
-We have touchpad gestures, but no touchscreen gestures yet.
-- **Wlr protocols**: yes, we have most of the important ones like layer-shell, gamma-control, screencopy.
-You can check on [wayland.app](https://wayland.app) at the bottom of each protocol's page.
-- **Performance**: while I run niri on beefy machines, I try to stay conscious of performance.
-I've seen someone use it fine on an Eee PC 900 from 2008, of all things.
-- **Xwayland**: no built-in support, but xwayland-satellite is [easy to set up](https://github.com/YaLTeR/niri/wiki/Xwayland#using-xwayland-satellite) and works very well.
-    - Steam and games, including Proton: work perfectly through xwayland-satellite.
-    - JetBrains IDEs, Ghidra: work well through xwayland-satellite.
-    - Discord and other Electron apps: work well through xwayland-satellite.
-    - Chromium and VSCode: work perfectly natively on Wayland with the right flags.
-    - X11 apps that want to position windows or bars at specific screen coordinates: won't work well; you can run them in a nested compositor like [labwc](https://github.com/YaLTeR/niri/wiki/Xwayland#using-the-labwc-wayland-compositor) or [rootful Xwayland](https://github.com/YaLTeR/niri/wiki/Xwayland#directly-running-xwayland-in-rootful-mode).
-    - Display scaling (integer or fractional) will make X11 apps look blurry; this needs to be supported in xwayland-satellite.
-    For games, you can run them in [gamescope] at native resolution, even with display scaling.
-
 ## Inspiration
 
 Niri is heavily inspired by [PaperWM] which implements scrollable tiling on top of GNOME Shell.
@@ -103,6 +78,3 @@ We have a Matrix chat, feel free to join and ask a question: https://matrix.to/#
 [hyprscroller]: https://github.com/dawsers/hyprscroller
 [hyprslidr]: https://gitlab.com/magus/hyprslidr
 [PaperWM.spoon]: https://github.com/mogenson/PaperWM.spoon
-[Matrix channel]: https://matrix.to/#/#niri:matrix.org
-[OpenTabletDriver]: https://opentabletdriver.net/
-[gamescope]: https://github.com/ValveSoftware/gamescope

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nix-filter": {
       "locked": {
-        "lastModified": 1731533336,
+        "lastModified": 1710156097,
-        "narHash": "sha256-oRam5PS1vcrr5UPgALW0eo1m/5/pls27Z/pabHNy2Ms=",
+        "narHash": "sha256-1Wvk8UP7PXdf8bCCaEoMnOT1qe5/Duqgj+rL8sRQsSM=",
         "owner": "numtide",
         "repo": "nix-filter",
-        "rev": "f7653272fd234696ae94229839a99b73c9ab7de0",
+        "rev": "3342559a24e85fc164b295c3444e8a139924675b",
         "type": "github"
       },
       "original": {
@@ -17,11 +17,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1733064805,
+        "lastModified": 1726365531,
-        "narHash": "sha256-7NbtSLfZO0q7MXPl5hzA0sbVJt6pWxxtGWbaVUDDmjs=",
+        "narHash": "sha256-luAKNxWZ+ZN0kaHchx1OdLQ71n81Y31ryNPWP1YRDZc=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "31d66ae40417bb13765b0ad75dd200400e98de84",
+        "rev": "9299cdf978e15f448cf82667b0ffdd480b44ee48",
         "type": "github"
       },
       "original": {
@@ -45,11 +45,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1733106880,
+        "lastModified": 1727663505,
-        "narHash": "sha256-aJmAIjZfWfPSWSExwrYBLRgXVvgF5LP1vaeUGOOIQ98=",
+        "narHash": "sha256-83j/GrHsx8GFUcQofKh+PRPz6pz8sxAsZyT/HCNdey8=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "e66c0d43abf5bdefb664c3583ca8994983c332ae",
+        "rev": "c2099c6c7599ea1980151b8b6247a8f93e1806ee",
         "type": "github"
       },
       "original": {

flake.nix

@@ -26,8 +26,10 @@
         {
           lib,
           cairo,
+          clang,
           dbus,
           libGL,
+          libclang,
           libdisplay-info,
           libinput,
           seatd,
@@ -77,7 +79,7 @@
           strictDeps = true;
 
           nativeBuildInputs = [
-            rustPlatform.bindgenHook
+            clang
             pkg-config
           ];
 
@@ -106,15 +108,6 @@
             ++ lib.optional withSystemd "systemd";
           buildNoDefaultFeatures = true;
 
-          # ever since this commit:
-          # https://github.com/YaLTeR/niri/commit/771ea1e81557ffe7af9cbdbec161601575b64d81
-          # niri now runs an actual instance of the real compositor (with a mock backend) during tests
-          # and thus creates a real socket file in the runtime dir.
-          # this is fine for our build, we just need to make sure it has a directory to write to.
-          preCheck = ''
-            export XDG_RUNTIME_DIR="$(mktemp -d)"
-          '';
-
           postInstall =
             ''
               install -Dm644 resources/niri.desktop -t $out/share/wayland-sessions
@@ -126,6 +119,8 @@
             '';
 
           env = {
+            LIBCLANG_PATH = lib.getLib libclang + "/lib";
+
             # Force linking with libEGL and libwayland-client
             # so they can be discovered by `dlopen()`
             RUSTFLAGS = toString (
@@ -196,7 +191,7 @@
             ];
 
             nativeBuildInputs = [
-              pkgs.rustPlatform.bindgenHook
+              pkgs.clang
               pkgs.pkg-config
               pkgs.wrapGAppsHook4 # For `niri-visual-tests`
             ];
@@ -206,6 +201,8 @@
             ];
 
             env = {
+              inherit (niri) LIBCLANG_PATH;
+
               # WARN: Do not overwrite this variable in your shell!
               # It is required for `dlopen()` to work on some libraries; see the comment
               # in the package expression

niri-config/Cargo.toml

@@ -11,13 +11,14 @@ repository.workspace = true
 bitflags.workspace = true
 csscolorparser = "0.7.0"
 knuffel = "3.2.0"
-miette = { version = "5.10.0", features = ["fancy-no-backtrace"] }
+miette = "5.10.0"
-niri-ipc = { version = "25.2.0", path = "../niri-ipc" }
+niri-ipc = { version = "0.1.10-1", path = "../niri-ipc" }
 regex = "1.11.1"
 smithay = { workspace = true, features = ["backend_libinput"] }
 tracing.workspace = true
 tracy-client.workspace = true
 
 [dev-dependencies]
-insta.workspace = true
+k9.workspace = true
+miette = { version = "5.10.0", features = ["fancy"] }
 pretty_assertions = "1.4.1"

niri-config/src/layer_rule.rs

@@ -1,26 +0,0 @@
-use crate::{BlockOutFrom, CornerRadius, RegexEq, ShadowRule};
-
-#[derive(knuffel::Decode, Debug, Default, Clone, PartialEq)]
-pub struct LayerRule {
-    #[knuffel(children(name = "match"))]
-    pub matches: Vec<Match>,
-    #[knuffel(children(name = "exclude"))]
-    pub excludes: Vec<Match>,
-
-    #[knuffel(child, unwrap(argument))]
-    pub opacity: Option<f32>,
-    #[knuffel(child, unwrap(argument))]
-    pub block_out_from: Option<BlockOutFrom>,
-    #[knuffel(child, default)]
-    pub shadow: ShadowRule,
-    #[knuffel(child)]
-    pub geometry_corner_radius: Option<CornerRadius>,
-}
-
-#[derive(knuffel::Decode, Debug, Default, Clone, PartialEq)]
-pub struct Match {
-    #[knuffel(property, str)]
-    pub namespace: Option<RegexEq>,
-    #[knuffel(property)]
-    pub at_startup: Option<bool>,
-}

niri-config/src/utils.rs

@@ -1,23 +0,0 @@
-use std::str::FromStr;
-
-use regex::Regex;
-
-/// `Regex` that implements `PartialEq` by its string form.
-#[derive(Debug, Clone)]
-pub struct RegexEq(pub Regex);
-
-impl PartialEq for RegexEq {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.as_str() == other.0.as_str()
-    }
-}
-
-impl Eq for RegexEq {}
-
-impl FromStr for RegexEq {
-    type Err = <Regex as FromStr>::Err;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Regex::from_str(s).map(Self)
-    }
-}

niri-ipc/README.md

@@ -12,5 +12,5 @@ Use an exact version requirement to avoid breaking changes:
 
 ```toml
 [dependencies]
-niri-ipc = "=25.2.0"
+niri-ipc = "=0.1.10"
 ```

niri-ipc/src/lib.rs

@@ -24,7 +24,7 @@
 //!
 //! ```toml
 //! [dependencies]
-//! niri-ipc = "=25.2.0"
+//! niri-ipc = "=0.1.10"
 //! ```
 //!
 //! ## Features
@@ -55,8 +55,6 @@ pub enum Request {
     Workspaces,
     /// Request information about open windows.
     Windows,
-    /// Request information about layer-shell surfaces.
-    Layers,
     /// Request information about the configured keyboard layouts.
     KeyboardLayouts,
     /// Request information about the focused output.
@@ -121,8 +119,6 @@ pub enum Response {
     Workspaces(Vec<Workspace>),
     /// Information about open windows.
     Windows(Vec<Window>),
-    /// Information about layer-shell surfaces.
-    Layers(Vec<LayerSurface>),
     /// Information about the keyboard layout.
     KeyboardLayouts(KeyboardLayouts),
     /// Information about the focused output.
@@ -167,13 +163,7 @@ pub enum Action {
     /// Open the screenshot UI.
     Screenshot {},
     /// Screenshot the focused screen.
-    ScreenshotScreen {
+    ScreenshotScreen {},
-        /// Write the screenshot to disk in addition to putting it in your clipboard.
-        ///
-        /// The screenshot is saved according to the `screenshot-path` config setting.
-        #[cfg_attr(feature = "clap", arg(short = 'd', long, action = clap::ArgAction::Set, default_value_t = true))]
-        write_to_disk: bool,
-    },
     /// Screenshot a window.
     #[cfg_attr(feature = "clap", clap(about = "Screenshot the focused window"))]
     ScreenshotWindow {
@@ -182,11 +172,6 @@ pub enum Action {
         /// If `None`, uses the focused window.
         #[cfg_attr(feature = "clap", arg(long))]
         id: Option<u64>,
-        /// Write the screenshot to disk in addition to putting it in your clipboard.
-        ///
-        /// The screenshot is saved according to the `screenshot-path` config setting.
-        #[cfg_attr(feature = "clap", arg(short = 'd', long, action = clap::ArgAction::Set, default_value_t = true))]
-        write_to_disk: bool,
     },
     /// Close a window.
     #[cfg_attr(feature = "clap", clap(about = "Close the focused window"))]
@@ -215,16 +200,6 @@ pub enum Action {
         #[cfg_attr(feature = "clap", arg(long))]
         id: u64,
     },
-    /// Focus a window in the focused column by index.
-    FocusWindowInColumn {
-        /// Index of the window in the column.
-        ///
-        /// The index starts from 1 for the topmost window.
-        #[cfg_attr(feature = "clap", arg())]
-        index: u8,
-    },
-    /// Focus the previously focused window.
-    FocusWindowPrevious {},
     /// Focus the column to the left.
     FocusColumnLeft {},
     /// Focus the column to the right.
@@ -261,14 +236,6 @@ pub enum Action {
     FocusWindowOrWorkspaceDown {},
     /// Focus the window or the workspace above.
     FocusWindowOrWorkspaceUp {},
-    /// Focus the topmost window.
-    FocusWindowTop {},
-    /// Focus the bottommost window.
-    FocusWindowBottom {},
-    /// Focus the window below or the topmost window.
-    FocusWindowDownOrTop {},
-    /// Focus the window above or the bottommost window.
-    FocusWindowUpOrBottom {},
     /// Move the focused column to the left.
     MoveColumnLeft {},
     /// Move the focused column to the right.
@@ -317,32 +284,8 @@ pub enum Action {
     ConsumeWindowIntoColumn {},
     /// Expel the focused window from the column.
     ExpelWindowFromColumn {},
-    /// Swap focused window with one to the right.
-    SwapWindowRight {},
-    /// Swap focused window with one to the left.
-    SwapWindowLeft {},
-    /// Toggle the focused column between normal and tabbed display.
-    ToggleColumnTabbedDisplay {},
-    /// Set the display mode of the focused column.
-    SetColumnDisplay {
-        /// Display mode to set.
-        #[cfg_attr(feature = "clap", arg())]
-        display: ColumnDisplay,
-    },
     /// Center the focused column on the screen.
     CenterColumn {},
-    /// Center a window on the screen.
-    #[cfg_attr(
-        feature = "clap",
-        clap(about = "Center the focused window on the screen")
-    )]
-    CenterWindow {
-        /// Id of the window to center.
-        ///
-        /// If `None`, uses the focused window.
-        #[cfg_attr(feature = "clap", arg(long))]
-        id: Option<u64>,
-    },
     /// Focus the workspace below.
     FocusWorkspaceDown {},
     /// Focus the workspace above.
@@ -389,50 +332,6 @@ pub enum Action {
     MoveWorkspaceDown {},
     /// Move the focused workspace up.
     MoveWorkspaceUp {},
-    /// Move a workspace to a specific index on its monitor.
-    #[cfg_attr(
-        feature = "clap",
-        clap(about = "Move the focused workspace to a specific index on its monitor")
-    )]
-    MoveWorkspaceToIndex {
-        /// New index for the workspace.
-        #[cfg_attr(feature = "clap", arg())]
-        index: usize,
-
-        /// Reference (index or name) of the workspace to move.
-        ///
-        /// If `None`, uses the focused workspace.
-        #[cfg_attr(feature = "clap", arg(long))]
-        reference: Option<WorkspaceReferenceArg>,
-    },
-    /// Set the name of a workspace.
-    #[cfg_attr(
-        feature = "clap",
-        clap(about = "Set the name of the focused workspace")
-    )]
-    SetWorkspaceName {
-        /// New name for the workspace.
-        #[cfg_attr(feature = "clap", arg())]
-        name: String,
-
-        /// Reference (index or name) of the workspace to name.
-        ///
-        /// If `None`, uses the focused workspace.
-        #[cfg_attr(feature = "clap", arg(long))]
-        workspace: Option<WorkspaceReferenceArg>,
-    },
-    /// Unset the name of a workspace.
-    #[cfg_attr(
-        feature = "clap",
-        clap(about = "Unset the name of the focused workspace")
-    )]
-    UnsetWorkspaceName {
-        /// Reference (index or name) of the workspace to unname.
-        ///
-        /// If `None`, uses the focused workspace.
-        #[cfg_attr(feature = "clap", arg())]
-        reference: Option<WorkspaceReferenceArg>,
-    },
     /// Focus the monitor to the left.
     FocusMonitorLeft {},
     /// Focus the monitor to the right.
@@ -441,10 +340,6 @@ pub enum Action {
     FocusMonitorDown {},
     /// Focus the monitor above.
     FocusMonitorUp {},
-    /// Focus the previous monitor.
-    FocusMonitorPrevious {},
-    /// Focus the next monitor.
-    FocusMonitorNext {},
     /// Move the focused window to the monitor to the left.
     MoveWindowToMonitorLeft {},
     /// Move the focused window to the monitor to the right.
@@ -453,10 +348,6 @@ pub enum Action {
     MoveWindowToMonitorDown {},
     /// Move the focused window to the monitor above.
     MoveWindowToMonitorUp {},
-    /// Move the focused window to the previous monitor.
-    MoveWindowToMonitorPrevious {},
-    /// Move the focused window to the next monitor.
-    MoveWindowToMonitorNext {},
     /// Move the focused column to the monitor to the left.
     MoveColumnToMonitorLeft {},
     /// Move the focused column to the monitor to the right.
@@ -465,26 +356,6 @@ pub enum Action {
     MoveColumnToMonitorDown {},
     /// Move the focused column to the monitor above.
     MoveColumnToMonitorUp {},
-    /// Move the focused column to the previous monitor.
-    MoveColumnToMonitorPrevious {},
-    /// Move the focused column to the next monitor.
-    MoveColumnToMonitorNext {},
-    /// Change the width of a window.
-    #[cfg_attr(
-        feature = "clap",
-        clap(about = "Change the width of the focused window")
-    )]
-    SetWindowWidth {
-        /// Id of the window whose width to set.
-        ///
-        /// If `None`, uses the focused window.
-        #[cfg_attr(feature = "clap", arg(long))]
-        id: Option<u64>,
-
-        /// How to change the width.
-        #[cfg_attr(feature = "clap", arg(allow_hyphen_values = true))]
-        change: SizeChange,
-    },
     /// Change the height of a window.
     #[cfg_attr(
         feature = "clap",
@@ -498,7 +369,7 @@ pub enum Action {
         id: Option<u64>,
 
         /// How to change the height.
-        #[cfg_attr(feature = "clap", arg(allow_hyphen_values = true))]
+        #[cfg_attr(feature = "clap", arg())]
         change: SizeChange,
     },
     /// Reset the height of a window back to automatic.
@@ -515,14 +386,6 @@ pub enum Action {
     },
     /// Switch between preset column widths.
     SwitchPresetColumnWidth {},
-    /// Switch between preset window widths.
-    SwitchPresetWindowWidth {
-        /// Id of the window whose width to switch.
-        ///
-        /// If `None`, uses the focused window.
-        #[cfg_attr(feature = "clap", arg(long))]
-        id: Option<u64>,
-    },
     /// Switch between preset window heights.
     SwitchPresetWindowHeight {
         /// Id of the window whose height to switch.
@@ -536,11 +399,9 @@ pub enum Action {
     /// Change the width of the focused column.
     SetColumnWidth {
         /// How to change the width.
-        #[cfg_attr(feature = "clap", arg(allow_hyphen_values = true))]
+        #[cfg_attr(feature = "clap", arg())]
         change: SizeChange,
     },
-    /// Expand the focused column to space not taken up by other fully visible columns.
-    ExpandColumnToAvailableWidth {},
     /// Switch between keyboard layouts.
     SwitchLayout {
         /// Layout to switch to.
@@ -557,97 +418,12 @@ pub enum Action {
     MoveWorkspaceToMonitorDown {},
     /// Move the focused workspace to the monitor above.
     MoveWorkspaceToMonitorUp {},
-    /// Move the focused workspace to the previous monitor.
-    MoveWorkspaceToMonitorPrevious {},
-    /// Move the focused workspace to the next monitor.
-    MoveWorkspaceToMonitorNext {},
-    /// Move a workspace to a specific monitor.
-    #[cfg_attr(
-        feature = "clap",
-        clap(about = "Move the focused workspace to a specific monitor")
-    )]
-    MoveWorkspaceToMonitor {
-        /// The target output name.
-        #[cfg_attr(feature = "clap", arg())]
-        output: String,
-
-        // Reference (index or name) of the workspace to move.
-        ///
-        /// If `None`, uses the focused workspace.
-        #[cfg_attr(feature = "clap", arg(long))]
-        reference: Option<WorkspaceReferenceArg>,
-    },
     /// Toggle a debug tint on windows.
     ToggleDebugTint {},
     /// Toggle visualization of render element opaque regions.
     DebugToggleOpaqueRegions {},
     /// Toggle visualization of output damage.
     DebugToggleDamage {},
-    /// Move the focused window between the floating and the tiling layout.
-    ToggleWindowFloating {
-        /// Id of the window to move.
-        ///
-        /// If `None`, uses the focused window.
-        #[cfg_attr(feature = "clap", arg(long))]
-        id: Option<u64>,
-    },
-    /// Move the focused window to the floating layout.
-    MoveWindowToFloating {
-        /// Id of the window to move.
-        ///
-        /// If `None`, uses the focused window.
-        #[cfg_attr(feature = "clap", arg(long))]
-        id: Option<u64>,
-    },
-    /// Move the focused window to the tiling layout.
-    MoveWindowToTiling {
-        /// Id of the window to move.
-        ///
-        /// If `None`, uses the focused window.
-        #[cfg_attr(feature = "clap", arg(long))]
-        id: Option<u64>,
-    },
-    /// Switches focus to the floating layout.
-    FocusFloating {},
-    /// Switches focus to the tiling layout.
-    FocusTiling {},
-    /// Toggles the focus between the floating and the tiling layout.
-    SwitchFocusBetweenFloatingAndTiling {},
-    /// Move a floating window on screen.
-    #[cfg_attr(feature = "clap", clap(about = "Move the floating window on screen"))]
-    MoveFloatingWindow {
-        /// Id of the window to move.
-        ///
-        /// If `None`, uses the focused window.
-        #[cfg_attr(feature = "clap", arg(long))]
-        id: Option<u64>,
-
-        /// How to change the X position.
-        #[cfg_attr(
-            feature = "clap",
-            arg(short, long, default_value = "+0", allow_negative_numbers = true)
-        )]
-        x: PositionChange,
-
-        /// How to change the Y position.
-        #[cfg_attr(
-            feature = "clap",
-            arg(short, long, default_value = "+0", allow_negative_numbers = true)
-        )]
-        y: PositionChange,
-    },
-    /// Toggle the opacity of a window.
-    #[cfg_attr(
-        feature = "clap",
-        clap(about = "Toggle the opacity of the focused window")
-    )]
-    ToggleWindowRuleOpacity {
-        /// Id of the window.
-        ///
-        /// If `None`, uses the focused window.
-        #[cfg_attr(feature = "clap", arg(long))]
-        id: Option<u64>,
-    },
 }
 
 /// Change in window or column size.
@@ -664,16 +440,6 @@ pub enum SizeChange {
     AdjustProportion(f64),
 }
 
-/// Change in floating window position.
-#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq)]
-#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
-pub enum PositionChange {
-    /// Set the position in logical pixels.
-    SetFixed(f64),
-    /// Add or subtract to the current position in logical pixels.
-    AdjustFixed(f64),
-}
-
 /// Workspace reference (id, index or name) to operate on.
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
@@ -694,18 +460,6 @@ pub enum LayoutSwitchTarget {
     Next,
     /// The previous configured layout.
     Prev,
-    /// The specific layout by index.
-    Index(u8),
-}
-
-/// How windows display in a column.
-#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
-pub enum ColumnDisplay {
-    /// Windows are tiled vertically across the working area height.
-    Normal,
-    /// Windows are in tabs.
-    Tabbed,
 }
 
 /// Output actions that niri can perform.
@@ -941,21 +695,12 @@ pub struct Window {
     pub title: Option<String>,
     /// Application ID, if set.
     pub app_id: Option<String>,
-    /// Process ID that created the Wayland connection for this window, if known.
-    ///
-    /// Currently, windows created by xdg-desktop-portal-gnome will have a `None` PID, but this may
-    /// change in the future.
-    pub pid: Option<i32>,
     /// Id of the workspace this window is on, if any.
     pub workspace_id: Option<u64>,
     /// Whether this window is currently focused.
     ///
     /// There can be either one focused window or zero (e.g. when a layer-shell surface has focus).
     pub is_focused: bool,
-    /// Whether this window is currently floating.
-    ///
-    /// If the window isn't floating then it is in the tiling layout.
-    pub is_floating: bool,
 }
 
 /// Output configuration change result.
@@ -1017,46 +762,6 @@ pub struct KeyboardLayouts {
     pub current_idx: u8,
 }
 
-/// A layer-shell layer.
-#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
-pub enum Layer {
-    /// The background layer.
-    Background,
-    /// The bottom layer.
-    Bottom,
-    /// The top layer.
-    Top,
-    /// The overlay layer.
-    Overlay,
-}
-
-/// Keyboard interactivity modes for a layer-shell surface.
-#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
-pub enum LayerSurfaceKeyboardInteractivity {
-    /// Surface cannot receive keyboard focus.
-    None,
-    /// Surface receives keyboard focus whenever possible.
-    Exclusive,
-    /// Surface receives keyboard focus on demand, e.g. when clicked.
-    OnDemand,
-}
-
-/// A layer-shell surface.
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
-#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
-pub struct LayerSurface {
-    /// Namespace provided by the layer-shell client.
-    pub namespace: String,
-    /// Name of the output the surface is on.
-    pub output: String,
-    /// Layer that the surface is on.
-    pub layer: Layer,
-    /// The surface's keyboard interactivity mode.
-    pub keyboard_interactivity: LayerSurfaceKeyboardInteractivity,
-}
-
 /// A compositor event.
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
@@ -1186,25 +891,6 @@ impl FromStr for SizeChange {
     }
 }
 
-impl FromStr for PositionChange {
-    type Err = &'static str;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let value = s;
-        match value.bytes().next() {
-            Some(b'-' | b'+') => {
-                let value = value.parse().map_err(|_| "error parsing value")?;
-                Ok(Self::AdjustFixed(value))
-            }
-            Some(_) => {
-                let value = value.parse().map_err(|_| "error parsing value")?;
-                Ok(Self::SetFixed(value))
-            }
-            None => Err("value is missing"),
-        }
-    }
-}
-
 impl FromStr for LayoutSwitchTarget {
     type Err = &'static str;
 
@@ -1212,22 +898,7 @@ impl FromStr for LayoutSwitchTarget {
         match s {
             "next" => Ok(Self::Next),
             "prev" => Ok(Self::Prev),
-            other => match other.parse() {
+            _ => Err(r#"invalid layout action, can be "next" or "prev""#),
-                Ok(layout) => Ok(Self::Index(layout)),
-                _ => Err(r#"invalid layout action, can be "next", "prev" or a layout index"#),
-            },
-        }
-    }
-}
-
-impl FromStr for ColumnDisplay {
-    type Err = &'static str;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "normal" => Ok(Self::Normal),
-            "tabbed" => Ok(Self::Tabbed),
-            _ => Err(r#"invalid column display, can be "normal" or "tabbed""#),
         }
     }
 }

niri-visual-tests/Cargo.toml

@@ -10,9 +10,9 @@ repository.workspace = true
 [dependencies]
 adw = { version = "0.7.1", package = "libadwaita", features = ["v1_4"] }
 anyhow.workspace = true
-gtk = { version = "0.9.6", package = "gtk4", features = ["v4_12"] }
+gtk = { version = "0.9.3", package = "gtk4", features = ["v4_12"] }
-niri = { version = "25.2.0", path = ".." }
+niri = { version = "0.1.10-1", path = ".." }
-niri-config = { version = "25.2.0", path = "../niri-config" }
+niri-config = { version = "0.1.10-1", path = "../niri-config" }
 smithay.workspace = true
 tracing.workspace = true
 tracing-subscriber.workspace = true

niri-visual-tests/src/cases/gradient_angle.rs

@@ -1,13 +1,15 @@
 use std::f32::consts::{FRAC_PI_2, PI};
+use std::sync::atomic::Ordering;
 use std::time::Duration;
 
+use niri::animation::ANIMATION_SLOWDOWN;
 use niri::render_helpers::border::BorderRenderElement;
 use niri_config::{Color, CornerRadius, GradientInterpolation};
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Physical, Point, Rectangle, Size};
+use smithay::utils::{Logical, Physical, Rectangle, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 
 pub struct GradientAngle {
     angle: f32,
@@ -15,7 +17,7 @@ pub struct GradientAngle {
 }
 
 impl GradientAngle {
-    pub fn new(_args: Args) -> Self {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
         Self {
             angle: 0.,
             prev_time: Duration::ZERO,
@@ -29,13 +31,20 @@ impl TestCase for GradientAngle {
     }
 
     fn advance_animations(&mut self, current_time: Duration) {
-        let delta = if self.prev_time.is_zero() {
+        let mut delta = if self.prev_time.is_zero() {
             Duration::ZERO
         } else {
             current_time.saturating_sub(self.prev_time)
         };
         self.prev_time = current_time;
 
+        let slowdown = ANIMATION_SLOWDOWN.load(Ordering::SeqCst);
+        if slowdown == 0. {
+            delta = Duration::ZERO
+        } else {
+            delta = delta.div_f64(slowdown);
+        }
+
         self.angle += delta.as_secs_f32() * PI;
 
         if self.angle >= PI * 2. {
@@ -50,20 +59,19 @@ impl TestCase for GradientAngle {
     ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
         let (a, b) = (size.w / 4, size.h / 4);
         let size = (size.w - a * 2, size.h - b * 2);
-        let area = Rectangle::new(Point::from((a, b)), Size::from(size)).to_f64();
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
 
         [BorderRenderElement::new(
             area.size,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             GradientInterpolation::default(),
             Color::new_unpremul(1., 0., 0., 1.),
             Color::new_unpremul(0., 1., 0., 1.),
             self.angle - FRAC_PI_2,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             0.,
             CornerRadius::default(),
             1.,
-            1.,
         )
         .with_location(area.loc)]
         .into_iter()

niri-visual-tests/src/cases/gradient_area.rs

@@ -1,14 +1,16 @@
 use std::f32::consts::{FRAC_PI_4, PI};
+use std::sync::atomic::Ordering;
 use std::time::Duration;
 
+use niri::animation::ANIMATION_SLOWDOWN;
 use niri::layout::focus_ring::FocusRing;
 use niri::render_helpers::border::BorderRenderElement;
 use niri_config::{Color, CornerRadius, FloatOrInt, GradientInterpolation};
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Physical, Point, Rectangle, Size};
+use smithay::utils::{Logical, Physical, Point, Rectangle, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 
 pub struct GradientArea {
     progress: f32,
@@ -17,7 +19,7 @@ pub struct GradientArea {
 }
 
 impl GradientArea {
-    pub fn new(_args: Args) -> Self {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
         let border = FocusRing::new(niri_config::FocusRing {
             off: false,
             width: FloatOrInt(1.),
@@ -41,13 +43,20 @@ impl TestCase for GradientArea {
     }
 
     fn advance_animations(&mut self, current_time: Duration) {
-        let delta = if self.prev_time.is_zero() {
+        let mut delta = if self.prev_time.is_zero() {
             Duration::ZERO
         } else {
             current_time.saturating_sub(self.prev_time)
         };
         self.prev_time = current_time;
 
+        let slowdown = ANIMATION_SLOWDOWN.load(Ordering::SeqCst);
+        if slowdown == 0. {
+            delta = Duration::ZERO
+        } else {
+            delta = delta.div_f64(slowdown);
+        }
+
         self.progress += delta.as_secs_f32() * PI;
 
         if self.progress >= PI * 2. {
@@ -65,8 +74,8 @@ impl TestCase for GradientArea {
         let f = (self.progress.sin() + 1.) / 2.;
 
         let (a, b) = (size.w / 4, size.h / 4);
-        let rect_size = Size::from((size.w - a * 2, size.h - b * 2));
+        let rect_size = (size.w - a * 2, size.h - b * 2);
-        let area = Rectangle::new(Point::from((a, b)), rect_size).to_f64();
+        let area = Rectangle::from_loc_and_size((a, b), rect_size).to_f64();
 
         let g_size = Size::from((
             (size.w as f32 / 8. + size.w as f32 / 8. * 7. * f).round() as i32,
@@ -74,7 +83,7 @@ impl TestCase for GradientArea {
         ));
         let g_loc = Point::from(((size.w - g_size.w) / 2, (size.h - g_size.h) / 2)).to_f64();
         let g_size = g_size.to_f64();
-        let mut g_area = Rectangle::new(g_loc, g_size);
+        let mut g_area = Rectangle::from_loc_and_size(g_loc, g_size);
         g_area.loc -= area.loc;
 
         self.border.update_render_elements(
@@ -84,7 +93,6 @@ impl TestCase for GradientArea {
             Rectangle::default(),
             CornerRadius::default(),
             1.,
-            1.,
         );
         rv.extend(
             self.border
@@ -100,11 +108,10 @@ impl TestCase for GradientArea {
                 Color::new_unpremul(1., 0., 0., 1.),
                 Color::new_unpremul(0., 1., 0., 1.),
                 FRAC_PI_4,
-                Rectangle::from_size(rect_size).to_f64(),
+                Rectangle::from_loc_and_size((0, 0), rect_size).to_f64(),
                 0.,
                 CornerRadius::default(),
                 1.,
-                1.,
             )
             .with_location(area.loc)]
             .into_iter()

niri-visual-tests/src/cases/gradient_oklab.rs

@@ -4,16 +4,16 @@ use niri_config::{
 };
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Physical, Point, Rectangle, Size};
+use smithay::utils::{Logical, Physical, Rectangle, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 
 pub struct GradientOklab {
     gradient_format: GradientInterpolation,
 }
 
 impl GradientOklab {
-    pub fn new(_args: Args) -> Self {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
         Self {
             gradient_format: GradientInterpolation {
                 color_space: GradientColorSpace::Oklab,
@@ -31,20 +31,19 @@ impl TestCase for GradientOklab {
     ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
         let (a, b) = (size.w / 6, size.h / 3);
         let size = (size.w - a * 2, size.h - b * 2);
-        let area = Rectangle::new(Point::from((a, b)), Size::from(size)).to_f64();
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
 
         [BorderRenderElement::new(
             area.size,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             self.gradient_format,
             Color::new_unpremul(1., 0., 0., 1.),
             Color::new_unpremul(0., 1., 0., 1.),
             0.,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             0.,
             CornerRadius::default(),
             1.,
-            1.,
         )
         .with_location(area.loc)]
         .into_iter()

niri-visual-tests/src/cases/gradient_oklab_alpha.rs

@@ -2,16 +2,16 @@ use niri::render_helpers::border::BorderRenderElement;
 use niri_config::{Color, CornerRadius, GradientColorSpace, GradientInterpolation};
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Physical, Point, Rectangle, Size};
+use smithay::utils::{Logical, Physical, Rectangle, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 
 pub struct GradientOklabAlpha {
     gradient_format: GradientInterpolation,
 }
 
 impl GradientOklabAlpha {
-    pub fn new(_args: Args) -> Self {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
         Self {
             gradient_format: GradientInterpolation {
                 color_space: GradientColorSpace::Oklab,
@@ -29,20 +29,19 @@ impl TestCase for GradientOklabAlpha {
     ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
         let (a, b) = (size.w / 6, size.h / 3);
         let size = (size.w - a * 2, size.h - b * 2);
-        let area = Rectangle::new(Point::from((a, b)), Size::from(size)).to_f64();
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
 
         [BorderRenderElement::new(
             area.size,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             self.gradient_format,
             Color::new_unpremul(1., 0., 0., 1.),
             Color::new_unpremul(0., 1., 0., 0.),
             0.,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             0.,
             CornerRadius::default(),
             1.,
-            1.,
         )
         .with_location(area.loc)]
         .into_iter()

niri-visual-tests/src/cases/gradient_oklch_alpha.rs

@@ -4,16 +4,16 @@ use niri_config::{
 };
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Physical, Point, Rectangle, Size};
+use smithay::utils::{Logical, Physical, Rectangle, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 
 pub struct GradientOklchAlpha {
     gradient_format: GradientInterpolation,
 }
 
 impl GradientOklchAlpha {
-    pub fn new(_args: Args) -> Self {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
         Self {
             gradient_format: GradientInterpolation {
                 color_space: GradientColorSpace::Oklch,
@@ -31,20 +31,19 @@ impl TestCase for GradientOklchAlpha {
     ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
         let (a, b) = (size.w / 6, size.h / 3);
         let size = (size.w - a * 2, size.h - b * 2);
-        let area = Rectangle::new(Point::from((a, b)), Size::from(size)).to_f64();
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
 
         [BorderRenderElement::new(
             area.size,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             self.gradient_format,
             Color::new_unpremul(1., 0., 0., 1.),
             Color::new_unpremul(0., 1., 0., 0.),
             0.,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             0.,
             CornerRadius::default(),
             1.,
-            1.,
         )
         .with_location(area.loc)]
         .into_iter()

niri-visual-tests/src/cases/gradient_oklch_decreasing.rs

@@ -4,16 +4,16 @@ use niri_config::{
 };
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Physical, Point, Rectangle, Size};
+use smithay::utils::{Logical, Physical, Rectangle, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 
 pub struct GradientOklchDecreasing {
     gradient_format: GradientInterpolation,
 }
 
 impl GradientOklchDecreasing {
-    pub fn new(_args: Args) -> Self {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
         Self {
             gradient_format: GradientInterpolation {
                 color_space: GradientColorSpace::Oklch,
@@ -31,20 +31,19 @@ impl TestCase for GradientOklchDecreasing {
     ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
         let (a, b) = (size.w / 6, size.h / 3);
         let size = (size.w - a * 2, size.h - b * 2);
-        let area = Rectangle::new(Point::from((a, b)), Size::from(size)).to_f64();
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
 
         [BorderRenderElement::new(
             area.size,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             self.gradient_format,
             Color::new_unpremul(1., 0., 0., 1.),
             Color::new_unpremul(0., 1., 0., 1.),
             0.,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             0.,
             CornerRadius::default(),
             1.,
-            1.,
         )
         .with_location(area.loc)]
         .into_iter()

niri-visual-tests/src/cases/gradient_oklch_increasing.rs

@@ -4,16 +4,16 @@ use niri_config::{
 };
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Physical, Point, Rectangle, Size};
+use smithay::utils::{Logical, Physical, Rectangle, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 
 pub struct GradientOklchIncreasing {
     gradient_format: GradientInterpolation,
 }
 
 impl GradientOklchIncreasing {
-    pub fn new(_args: Args) -> Self {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
         Self {
             gradient_format: GradientInterpolation {
                 color_space: GradientColorSpace::Oklch,
@@ -31,20 +31,19 @@ impl TestCase for GradientOklchIncreasing {
     ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
         let (a, b) = (size.w / 6, size.h / 3);
         let size = (size.w - a * 2, size.h - b * 2);
-        let area = Rectangle::new(Point::from((a, b)), Size::from(size)).to_f64();
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
 
         [BorderRenderElement::new(
             area.size,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             self.gradient_format,
             Color::new_unpremul(1., 0., 0., 1.),
             Color::new_unpremul(0., 1., 0., 1.),
             0.,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             0.,
             CornerRadius::default(),
             1.,
-            1.,
         )
         .with_location(area.loc)]
         .into_iter()

niri-visual-tests/src/cases/gradient_oklch_longer.rs

@@ -4,16 +4,16 @@ use niri_config::{
 };
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Physical, Point, Rectangle, Size};
+use smithay::utils::{Logical, Physical, Rectangle, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 
 pub struct GradientOklchLonger {
     gradient_format: GradientInterpolation,
 }
 
 impl GradientOklchLonger {
-    pub fn new(_args: Args) -> Self {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
         Self {
             gradient_format: GradientInterpolation {
                 color_space: GradientColorSpace::Oklch,
@@ -31,20 +31,19 @@ impl TestCase for GradientOklchLonger {
     ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
         let (a, b) = (size.w / 6, size.h / 3);
         let size = (size.w - a * 2, size.h - b * 2);
-        let area = Rectangle::new(Point::from((a, b)), Size::from(size)).to_f64();
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
 
         [BorderRenderElement::new(
             area.size,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             self.gradient_format,
             Color::new_unpremul(1., 0., 0., 1.),
             Color::new_unpremul(0., 1., 0., 1.),
             0.,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             0.,
             CornerRadius::default(),
             1.,
-            1.,
         )
         .with_location(area.loc)]
         .into_iter()

niri-visual-tests/src/cases/gradient_oklch_shorter.rs

@@ -4,16 +4,16 @@ use niri_config::{
 };
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Physical, Point, Rectangle, Size};
+use smithay::utils::{Logical, Physical, Rectangle, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 
 pub struct GradientOklchShorter {
     gradient_format: GradientInterpolation,
 }
 
 impl GradientOklchShorter {
-    pub fn new(_args: Args) -> Self {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
         Self {
             gradient_format: GradientInterpolation {
                 color_space: GradientColorSpace::Oklch,
@@ -31,20 +31,19 @@ impl TestCase for GradientOklchShorter {
     ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
         let (a, b) = (size.w / 6, size.h / 3);
         let size = (size.w - a * 2, size.h - b * 2);
-        let area = Rectangle::new(Point::from((a, b)), Size::from(size)).to_f64();
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
 
         [BorderRenderElement::new(
             area.size,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             self.gradient_format,
             Color::new_unpremul(1., 0., 0., 1.),
             Color::new_unpremul(0., 1., 0., 1.),
             0.,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             0.,
             CornerRadius::default(),
             1.,
-            1.,
         )
         .with_location(area.loc)]
         .into_iter()

niri-visual-tests/src/cases/gradient_srgb.rs

@@ -4,16 +4,16 @@ use niri_config::{
 };
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Physical, Point, Rectangle, Size};
+use smithay::utils::{Logical, Physical, Rectangle, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 
 pub struct GradientSrgb {
     gradient_format: GradientInterpolation,
 }
 
 impl GradientSrgb {
-    pub fn new(_args: Args) -> Self {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
         Self {
             gradient_format: GradientInterpolation {
                 color_space: GradientColorSpace::Srgb,
@@ -31,20 +31,19 @@ impl TestCase for GradientSrgb {
     ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
         let (a, b) = (size.w / 6, size.h / 3);
         let size = (size.w - a * 2, size.h - b * 2);
-        let area = Rectangle::new(Point::from((a, b)), Size::from(size)).to_f64();
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
 
         [BorderRenderElement::new(
             area.size,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             self.gradient_format,
             Color::new_unpremul(1., 0., 0., 1.),
             Color::new_unpremul(0., 1., 0., 1.),
             0.,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             0.,
             CornerRadius::default(),
             1.,
-            1.,
         )
         .with_location(area.loc)]
         .into_iter()

niri-visual-tests/src/cases/gradient_srgb_alpha.rs

@@ -2,16 +2,16 @@ use niri::render_helpers::border::BorderRenderElement;
 use niri_config::{Color, CornerRadius, GradientColorSpace, GradientInterpolation};
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Physical, Point, Rectangle, Size};
+use smithay::utils::{Logical, Physical, Rectangle, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 
 pub struct GradientSrgbAlpha {
     gradient_format: GradientInterpolation,
 }
 
 impl GradientSrgbAlpha {
-    pub fn new(_args: Args) -> Self {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
         Self {
             gradient_format: GradientInterpolation {
                 color_space: GradientColorSpace::Srgb,
@@ -29,20 +29,19 @@ impl TestCase for GradientSrgbAlpha {
     ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
         let (a, b) = (size.w / 6, size.h / 3);
         let size = (size.w - a * 2, size.h - b * 2);
-        let area = Rectangle::new(Point::from((a, b)), Size::from(size)).to_f64();
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
 
         [BorderRenderElement::new(
             area.size,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             self.gradient_format,
             Color::new_unpremul(1., 0., 0., 1.),
             Color::new_unpremul(0., 1., 0., 0.),
             0.,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             0.,
             CornerRadius::default(),
             1.,
-            1.,
         )
         .with_location(area.loc)]
         .into_iter()

niri-visual-tests/src/cases/gradient_srgblinear.rs

@@ -4,16 +4,16 @@ use niri_config::{
 };
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Physical, Point, Rectangle, Size};
+use smithay::utils::{Logical, Physical, Rectangle, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 
 pub struct GradientSrgbLinear {
     gradient_format: GradientInterpolation,
 }
 
 impl GradientSrgbLinear {
-    pub fn new(_args: Args) -> Self {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
         Self {
             gradient_format: GradientInterpolation {
                 color_space: GradientColorSpace::SrgbLinear,
@@ -31,20 +31,19 @@ impl TestCase for GradientSrgbLinear {
     ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
         let (a, b) = (size.w / 6, size.h / 3);
         let size = (size.w - a * 2, size.h - b * 2);
-        let area = Rectangle::new(Point::from((a, b)), Size::from(size)).to_f64();
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
 
         [BorderRenderElement::new(
             area.size,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             self.gradient_format,
             Color::new_unpremul(1., 0., 0., 1.),
             Color::new_unpremul(0., 1., 0., 1.),
             0.,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             0.,
             CornerRadius::default(),
             1.,
-            1.,
         )
         .with_location(area.loc)]
         .into_iter()

niri-visual-tests/src/cases/gradient_srgblinear_alpha.rs

@@ -2,16 +2,16 @@ use niri::render_helpers::border::BorderRenderElement;
 use niri_config::{Color, CornerRadius, GradientColorSpace, GradientInterpolation};
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Physical, Point, Rectangle, Size};
+use smithay::utils::{Logical, Physical, Rectangle, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 
 pub struct GradientSrgbLinearAlpha {
     gradient_format: GradientInterpolation,
 }
 
 impl GradientSrgbLinearAlpha {
-    pub fn new(_args: Args) -> Self {
+    pub fn new(_size: Size<i32, Logical>) -> Self {
         Self {
             gradient_format: GradientInterpolation {
                 color_space: GradientColorSpace::SrgbLinear,
@@ -29,20 +29,19 @@ impl TestCase for GradientSrgbLinearAlpha {
     ) -> Vec<Box<dyn RenderElement<GlesRenderer>>> {
         let (a, b) = (size.w / 6, size.h / 3);
         let size = (size.w - a * 2, size.h - b * 2);
-        let area = Rectangle::new(Point::from((a, b)), Size::from(size)).to_f64();
+        let area = Rectangle::from_loc_and_size((a, b), size).to_f64();
 
         [BorderRenderElement::new(
             area.size,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             self.gradient_format,
             Color::new_unpremul(1., 0., 0., 1.),
             Color::new_unpremul(0., 1., 0., 0.),
             0.,
-            Rectangle::from_size(area.size),
+            Rectangle::from_loc_and_size((0., 0.), area.size),
             0.,
             CornerRadius::default(),
             1.,
-            1.,
         )
         .with_location(area.loc)]
         .into_iter()

niri-visual-tests/src/cases/layout.rs

@@ -1,17 +1,18 @@
 use std::collections::HashMap;
 use std::time::Duration;
 
-use niri::animation::Clock;
+use niri::layout::workspace::ColumnWidth;
-use niri::layout::{ActivateWindow, AddWindowTarget, LayoutElement as _, Options};
+use niri::layout::{LayoutElement as _, Options};
 use niri::render_helpers::RenderTarget;
-use niri_config::{Color, FloatOrInt, OutputName, PresetSize};
+use niri::utils::get_monotonic_time;
+use niri_config::{Color, FloatOrInt, OutputName};
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
 use smithay::desktop::layer_map_for_output;
 use smithay::output::{Mode, Output, PhysicalProperties, Subpixel};
-use smithay::utils::{Physical, Size};
+use smithay::utils::{Logical, Physical, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 use crate::test_window::TestWindow;
 
 type DynStepFn = Box<dyn FnOnce(&mut Layout)>;
@@ -19,16 +20,13 @@ type DynStepFn = Box<dyn FnOnce(&mut Layout)>;
 pub struct Layout {
     output: Output,
     windows: Vec<TestWindow>,
-    clock: Clock,
     layout: niri::layout::Layout<TestWindow>,
     start_time: Duration,
     steps: HashMap<Duration, DynStepFn>,
 }
 
 impl Layout {
-    pub fn new(args: Args) -> Self {
+    pub fn new(size: Size<i32, Logical>) -> Self {
-        let Args { size, clock } = args;
-
         let output = Output::new(
             String::new(),
             PhysicalProperties {
@@ -65,44 +63,41 @@ impl Layout {
             },
             ..Default::default()
         };
-        let mut layout = niri::layout::Layout::with_options(clock.clone(), options);
+        let mut layout = niri::layout::Layout::with_options(options);
         layout.add_output(output.clone());
 
-        let start_time = clock.now_unadjusted();
-
         Self {
             output,
             windows: Vec::new(),
-            clock,
             layout,
-            start_time,
+            start_time: get_monotonic_time(),
             steps: HashMap::new(),
         }
     }
 
-    pub fn open_in_between(args: Args) -> Self {
+    pub fn open_in_between(size: Size<i32, Logical>) -> Self {
-        let mut rv = Self::new(args);
+        let mut rv = Self::new(size);
 
-        rv.add_window(TestWindow::freeform(0), Some(PresetSize::Proportion(0.3)));
+        rv.add_window(TestWindow::freeform(0), Some(ColumnWidth::Proportion(0.3)));
-        rv.add_window(TestWindow::freeform(1), Some(PresetSize::Proportion(0.3)));
+        rv.add_window(TestWindow::freeform(1), Some(ColumnWidth::Proportion(0.3)));
         rv.layout.activate_window(&0);
 
         rv.add_step(500, |l| {
             let win = TestWindow::freeform(2);
-            l.add_window(win.clone(), Some(PresetSize::Proportion(0.3)));
+            l.add_window(win.clone(), Some(ColumnWidth::Proportion(0.3)));
             l.layout.start_open_animation_for_window(win.id());
         });
 
         rv
     }
 
-    pub fn open_multiple_quickly(args: Args) -> Self {
+    pub fn open_multiple_quickly(size: Size<i32, Logical>) -> Self {
-        let mut rv = Self::new(args);
+        let mut rv = Self::new(size);
 
         for delay in [100, 200, 300] {
             rv.add_step(delay, move |l| {
                 let win = TestWindow::freeform(delay as usize);
-                l.add_window(win.clone(), Some(PresetSize::Proportion(0.3)));
+                l.add_window(win.clone(), Some(ColumnWidth::Proportion(0.3)));
                 l.layout.start_open_animation_for_window(win.id());
             });
         }
@@ -110,13 +105,13 @@ impl Layout {
         rv
     }
 
-    pub fn open_multiple_quickly_big(args: Args) -> Self {
+    pub fn open_multiple_quickly_big(size: Size<i32, Logical>) -> Self {
-        let mut rv = Self::new(args);
+        let mut rv = Self::new(size);
 
         for delay in [100, 200, 300] {
             rv.add_step(delay, move |l| {
                 let win = TestWindow::freeform(delay as usize);
-                l.add_window(win.clone(), Some(PresetSize::Proportion(0.5)));
+                l.add_window(win.clone(), Some(ColumnWidth::Proportion(0.5)));
                 l.layout.start_open_animation_for_window(win.id());
             });
         }
@@ -124,58 +119,44 @@ impl Layout {
         rv
     }
 
-    pub fn open_to_the_left(args: Args) -> Self {
+    pub fn open_to_the_left(size: Size<i32, Logical>) -> Self {
-        let mut rv = Self::new(args);
+        let mut rv = Self::new(size);
 
-        rv.add_window(TestWindow::freeform(0), Some(PresetSize::Proportion(0.3)));
+        rv.add_window(TestWindow::freeform(0), Some(ColumnWidth::Proportion(0.3)));
-        rv.add_window(TestWindow::freeform(1), Some(PresetSize::Proportion(0.3)));
+        rv.add_window(TestWindow::freeform(1), Some(ColumnWidth::Proportion(0.3)));
 
         rv.add_step(500, |l| {
             let win = TestWindow::freeform(2);
             let right_of = l.windows[0].clone();
-            l.add_window_right_of(&right_of, win.clone(), Some(PresetSize::Proportion(0.3)));
+            l.add_window_right_of(&right_of, win.clone(), Some(ColumnWidth::Proportion(0.3)));
             l.layout.start_open_animation_for_window(win.id());
         });
 
         rv
     }
 
-    pub fn open_to_the_left_big(args: Args) -> Self {
+    pub fn open_to_the_left_big(size: Size<i32, Logical>) -> Self {
-        let mut rv = Self::new(args);
+        let mut rv = Self::new(size);
 
-        rv.add_window(TestWindow::freeform(0), Some(PresetSize::Proportion(0.3)));
+        rv.add_window(TestWindow::freeform(0), Some(ColumnWidth::Proportion(0.3)));
-        rv.add_window(TestWindow::freeform(1), Some(PresetSize::Proportion(0.8)));
+        rv.add_window(TestWindow::freeform(1), Some(ColumnWidth::Proportion(0.8)));
 
         rv.add_step(500, |l| {
             let win = TestWindow::freeform(2);
             let right_of = l.windows[0].clone();
-            l.add_window_right_of(&right_of, win.clone(), Some(PresetSize::Proportion(0.5)));
+            l.add_window_right_of(&right_of, win.clone(), Some(ColumnWidth::Proportion(0.5)));
             l.layout.start_open_animation_for_window(win.id());
         });
 
         rv
     }
 
-    fn add_window(&mut self, mut window: TestWindow, width: Option<PresetSize>) {
+    fn add_window(&mut self, mut window: TestWindow, width: Option<ColumnWidth>) {
         let ws = self.layout.active_workspace().unwrap();
-        let min_size = window.min_size();
+        window.request_size(ws.new_window_size(width, window.rules()), false, None);
-        let max_size = window.max_size();
-        window.request_size(
-            ws.new_window_size(width, None, false, window.rules(), (min_size, max_size)),
-            false,
-            None,
-        );
         window.communicate();
 
-        self.layout.add_window(
+        self.layout.add_window(window.clone(), width, false);
-            window.clone(),
-            AddWindowTarget::Auto,
-            width,
-            None,
-            false,
-            false,
-            ActivateWindow::default(),
-        );
         self.windows.push(window);
     }
 
@@ -183,27 +164,14 @@ impl Layout {
         &mut self,
         right_of: &TestWindow,
         mut window: TestWindow,
-        width: Option<PresetSize>,
+        width: Option<ColumnWidth>,
     ) {
         let ws = self.layout.active_workspace().unwrap();
-        let min_size = window.min_size();
+        window.request_size(ws.new_window_size(width, window.rules()), false, None);
-        let max_size = window.max_size();
-        window.request_size(
-            ws.new_window_size(width, None, false, window.rules(), (min_size, max_size)),
-            false,
-            None,
-        );
         window.communicate();
 
-        self.layout.add_window(
+        self.layout
-            window.clone(),
+            .add_window_right_of(right_of.id(), window.clone(), width, false);
-            AddWindowTarget::NextTo(right_of.id()),
-            width,
-            None,
-            false,
-            false,
-            ActivateWindow::default(),
-        );
         self.windows.push(window);
     }
 
@@ -233,25 +201,22 @@ impl TestCase for Layout {
         self.layout.are_animations_ongoing(Some(&self.output)) || !self.steps.is_empty()
     }
 
-    fn advance_animations(&mut self, _current_time: Duration) {
+    fn advance_animations(&mut self, mut current_time: Duration) {
-        let now_unadjusted = self.clock.now_unadjusted();
         let run = self
             .steps
             .keys()
             .copied()
-            .filter(|delay| self.start_time + *delay <= now_unadjusted)
+            .filter(|delay| self.start_time + *delay <= current_time)
             .collect::<Vec<_>>();
-        for delay in &run {
+        for key in &run {
-            let now = self.start_time + *delay;
+            let f = self.steps.remove(key).unwrap();
-            self.clock.set_unadjusted(now);
-            self.layout.advance_animations();
-
-            let f = self.steps.remove(delay).unwrap();
             f(self);
         }
+        if !run.is_empty() {
+            current_time = get_monotonic_time();
+        }
 
-        self.clock.set_unadjusted(now_unadjusted);
+        self.layout.advance_animations(current_time);
-        self.layout.advance_animations();
     }
 
     fn render(
@@ -263,7 +228,7 @@ impl TestCase for Layout {
         self.layout
             .monitor_for_output(&self.output)
             .unwrap()
-            .render_elements(renderer, RenderTarget::Output, true)
+            .render_elements(renderer, RenderTarget::Output)
             .map(|elem| Box::new(elem) as _)
             .collect()
     }

niri-visual-tests/src/cases/mod.rs

@@ -1,9 +1,8 @@
 use std::time::Duration;
 
-use niri::animation::Clock;
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Logical, Physical, Size};
+use smithay::utils::{Physical, Size};
 
 pub mod gradient_angle;
 pub mod gradient_area;
@@ -22,11 +21,6 @@ pub mod layout;
 pub mod tile;
 pub mod window;
 
-pub struct Args {
-    pub size: Size<i32, Logical>,
-    pub clock: Clock,
-}
-
 pub trait TestCase {
     fn resize(&mut self, _width: i32, _height: i32) {}
     fn are_animations_ongoing(&self) -> bool {

niri-visual-tests/src/cases/tile.rs

@@ -6,9 +6,9 @@ use niri::render_helpers::RenderTarget;
 use niri_config::{Color, FloatOrInt};
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Physical, Point, Rectangle, Scale, Size};
+use smithay::utils::{Logical, Physical, Point, Rectangle, Scale, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 use crate::test_window::TestWindow;
 
 pub struct Tile {
@@ -17,46 +17,53 @@ pub struct Tile {
 }
 
 impl Tile {
-    pub fn freeform(args: Args) -> Self {
+    pub fn freeform(size: Size<i32, Logical>) -> Self {
         let window = TestWindow::freeform(0);
-        Self::with_window(args, window)
+        let mut rv = Self::with_window(window);
+        rv.tile.request_tile_size(size.to_f64(), false, None);
+        rv.window.communicate();
+        rv
     }
 
-    pub fn fixed_size(args: Args) -> Self {
+    pub fn fixed_size(size: Size<i32, Logical>) -> Self {
         let window = TestWindow::fixed_size(0);
-        Self::with_window(args, window)
+        let mut rv = Self::with_window(window);
+        rv.tile.request_tile_size(size.to_f64(), false, None);
+        rv.window.communicate();
+        rv
     }
 
-    pub fn fixed_size_with_csd_shadow(args: Args) -> Self {
+    pub fn fixed_size_with_csd_shadow(size: Size<i32, Logical>) -> Self {
         let window = TestWindow::fixed_size(0);
         window.set_csd_shadow_width(64);
-        Self::with_window(args, window)
+        let mut rv = Self::with_window(window);
+        rv.tile.request_tile_size(size.to_f64(), false, None);
+        rv.window.communicate();
+        rv
     }
 
-    pub fn freeform_open(args: Args) -> Self {
+    pub fn freeform_open(size: Size<i32, Logical>) -> Self {
-        let mut rv = Self::freeform(args);
+        let mut rv = Self::freeform(size);
         rv.window.set_color([0.1, 0.1, 0.1, 1.]);
         rv.tile.start_open_animation();
         rv
     }
 
-    pub fn fixed_size_open(args: Args) -> Self {
+    pub fn fixed_size_open(size: Size<i32, Logical>) -> Self {
-        let mut rv = Self::fixed_size(args);
+        let mut rv = Self::fixed_size(size);
         rv.window.set_color([0.1, 0.1, 0.1, 1.]);
         rv.tile.start_open_animation();
         rv
     }
 
-    pub fn fixed_size_with_csd_shadow_open(args: Args) -> Self {
+    pub fn fixed_size_with_csd_shadow_open(size: Size<i32, Logical>) -> Self {
-        let mut rv = Self::fixed_size_with_csd_shadow(args);
+        let mut rv = Self::fixed_size_with_csd_shadow(size);
         rv.window.set_color([0.1, 0.1, 0.1, 1.]);
         rv.tile.start_open_animation();
         rv
     }
 
-    pub fn with_window(args: Args, window: TestWindow) -> Self {
+    pub fn with_window(window: TestWindow) -> Self {
-        let Args { size, clock } = args;
-
         let options = Options {
             focus_ring: niri_config::FocusRing {
                 off: true,
@@ -70,28 +77,15 @@ impl Tile {
             },
             ..Default::default()
         };
-
+        let tile = niri::layout::tile::Tile::new(window.clone(), 1., Rc::new(options));
-        let mut tile = niri::layout::tile::Tile::new(
-            window.clone(),
-            size.to_f64(),
-            1.,
-            clock,
-            Rc::new(options),
-        );
-
-        tile.request_tile_size(size.to_f64(), false, None);
-        window.communicate();
-
         Self { window, tile }
     }
 }
 
 impl TestCase for Tile {
     fn resize(&mut self, width: i32, height: i32) {
-        let size = Size::from((width, height)).to_f64();
         self.tile
-            .update_config(size, 1., self.tile.options().clone());
+            .request_tile_size(Size::from((width, height)).to_f64(), false, None);
-        self.tile.request_tile_size(size, false, None);
         self.window.communicate();
     }
 
@@ -99,8 +93,8 @@ impl TestCase for Tile {
         self.tile.are_animations_ongoing()
     }
 
-    fn advance_animations(&mut self, _current_time: Duration) {
+    fn advance_animations(&mut self, current_time: Duration) {
-        self.tile.advance_animations();
+        self.tile.advance_animations(current_time);
     }
 
     fn render(
@@ -112,9 +106,9 @@ impl TestCase for Tile {
         let tile_size = self.tile.tile_size().to_physical(1.);
         let location = Point::from((size.w - tile_size.w, size.h - tile_size.h)).downscale(2.);
 
-        self.tile.update_render_elements(
+        self.tile.update(
             true,
-            Rectangle::new(Point::from((-location.x, -location.y)), size.to_logical(1.)),
+            Rectangle::from_loc_and_size((-location.x, -location.y), size.to_logical(1.)),
         );
         self.tile
             .render(

niri-visual-tests/src/cases/window.rs

@@ -2,9 +2,9 @@ use niri::layout::LayoutElement;
 use niri::render_helpers::RenderTarget;
 use smithay::backend::renderer::element::RenderElement;
 use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Physical, Point, Scale, Size};
+use smithay::utils::{Logical, Physical, Point, Scale, Size};
 
-use super::{Args, TestCase};
+use super::TestCase;
 use crate::test_window::TestWindow;
 
 pub struct Window {
@@ -12,24 +12,24 @@ pub struct Window {
 }
 
 impl Window {
-    pub fn freeform(args: Args) -> Self {
+    pub fn freeform(size: Size<i32, Logical>) -> Self {
         let mut window = TestWindow::freeform(0);
-        window.request_size(args.size, false, None);
+        window.request_size(size, false, None);
         window.communicate();
         Self { window }
     }
 
-    pub fn fixed_size(args: Args) -> Self {
+    pub fn fixed_size(size: Size<i32, Logical>) -> Self {
         let mut window = TestWindow::fixed_size(0);
-        window.request_size(args.size, false, None);
+        window.request_size(size, false, None);
         window.communicate();
         Self { window }
     }
 
-    pub fn fixed_size_with_csd_shadow(args: Args) -> Self {
+    pub fn fixed_size_with_csd_shadow(size: Size<i32, Logical>) -> Self {
         let mut window = TestWindow::fixed_size(0);
         window.set_csd_shadow_width(64);
-        window.request_size(args.size, false, None);
+        window.request_size(size, false, None);
         window.communicate();
         Self { window }
     }

niri-visual-tests/src/main.rs

@@ -2,11 +2,15 @@
 extern crate tracing;
 
 use std::env;
+use std::sync::atomic::Ordering;
 
 use adw::prelude::{AdwApplicationWindowExt, NavigationPageExt};
-use cases::Args;
+use gtk::prelude::{
-use gtk::prelude::{ApplicationExt, ApplicationExtManual, BoxExt, GtkWindowExt, WidgetExt};
+    AdjustmentExt, ApplicationExt, ApplicationExtManual, BoxExt, GtkWindowExt, WidgetExt,
+};
 use gtk::{gdk, gio, glib};
+use niri::animation::ANIMATION_SLOWDOWN;
+use smithay::utils::{Logical, Size};
 use smithay_view::SmithayView;
 use tracing_subscriber::EnvFilter;
 
@@ -62,23 +66,24 @@ fn on_startup(_app: &adw::Application) {
 
 fn build_ui(app: &adw::Application) {
     let stack = gtk::Stack::new();
-    let anim_adjustment = gtk::Adjustment::new(1., 0., 10., 0.1, 0.5, 0.);
 
     struct S {
         stack: gtk::Stack,
-        anim_adjustment: gtk::Adjustment,
     }
 
     impl S {
-        fn add<T: TestCase + 'static>(&self, make: impl Fn(Args) -> T + 'static, title: &str) {
+        fn add<T: TestCase + 'static>(
-            let view = SmithayView::new(make, &self.anim_adjustment);
+            &self,
+            make: impl Fn(Size<i32, Logical>) -> T + 'static,
+            title: &str,
+        ) {
+            let view = SmithayView::new(make);
             self.stack.add_titled(&view, None, title);
         }
     }
 
     let s = S {
         stack: stack.clone(),
-        anim_adjustment: anim_adjustment.clone(),
     };
 
     s.add(Window::freeform, "Freeform Window");
@@ -132,6 +137,9 @@ fn build_ui(app: &adw::Application) {
 
     let content_headerbar = adw::HeaderBar::new();
 
+    let anim_adjustment = gtk::Adjustment::new(1., 0., 10., 0.1, 0.5, 0.);
+    anim_adjustment
+        .connect_value_changed(|adj| ANIMATION_SLOWDOWN.store(adj.value(), Ordering::SeqCst));
     let anim_scale = gtk::Scale::new(gtk::Orientation::Horizontal, Some(&anim_adjustment));
     anim_scale.set_hexpand(true);
 

niri-visual-tests/src/smithay_view.rs

@@ -1,20 +1,18 @@
 use gtk::glib;
-use gtk::prelude::*;
 use gtk::subclass::prelude::*;
-use smithay::utils::Size;
+use smithay::utils::{Logical, Size};
 
-use crate::cases::{Args, TestCase};
+use crate::cases::TestCase;
 
 mod imp {
     use std::cell::{Cell, OnceCell, RefCell};
     use std::ptr::null;
-    use std::time::Duration;
 
     use anyhow::{ensure, Context};
     use gtk::gdk;
     use gtk::prelude::*;
-    use niri::animation::Clock;
     use niri::render_helpers::{resources, shaders};
+    use niri::utils::get_monotonic_time;
     use smithay::backend::egl::ffi::egl;
     use smithay::backend::egl::EGLContext;
     use smithay::backend::renderer::gles::GlesRenderer;
@@ -23,7 +21,7 @@ mod imp {
 
     use super::*;
 
-    type DynMakeTestCase = Box<dyn Fn(Args) -> Box<dyn TestCase>>;
+    type DynMakeTestCase = Box<dyn Fn(Size<i32, Logical>) -> Box<dyn TestCase>>;
 
     #[derive(Default)]
     pub struct SmithayView {
@@ -32,7 +30,6 @@ mod imp {
         renderer: RefCell<Option<Result<GlesRenderer, ()>>>,
         pub make_test_case: OnceCell<DynMakeTestCase>,
         test_case: RefCell<Option<Box<dyn TestCase>>>,
-        pub clock: RefCell<Clock>,
     }
 
     #[glib::object_subclass]
@@ -128,24 +125,16 @@ mod imp {
 
             let size = self.size.get();
 
-            let frame_clock = self.obj().frame_clock().unwrap();
-            let time = Duration::from_micros(frame_clock.frame_time() as u64);
-            self.clock.borrow_mut().set_unadjusted(time);
-
             // Create the test case if missing.
             let mut case = self.test_case.borrow_mut();
             let case = case.get_or_insert_with(|| {
                 let make = self.make_test_case.get().unwrap();
-                let args = Args {
+                make(Size::from(size))
-                    size: Size::from(size),
-                    clock: self.clock.borrow().clone(),
-                };
-                make(args)
             });
 
-            case.advance_animations(self.clock.borrow_mut().now());
+            case.advance_animations(get_monotonic_time());
 
-            let rect: Rectangle<i32, Physical> = Rectangle::from_size(Size::from(size));
+            let rect: Rectangle<i32, Physical> = Rectangle::from_loc_and_size((0, 0), size);
 
             let elements = unsafe {
                 with_framebuffer_save_restore(renderer, |renderer| {
@@ -244,32 +233,14 @@ glib::wrapper! {
 
 impl SmithayView {
     pub fn new<T: TestCase + 'static>(
-        make_test_case: impl Fn(Args) -> T + 'static,
+        make_test_case: impl Fn(Size<i32, Logical>) -> T + 'static,
-        anim_adjustment: &gtk::Adjustment,
     ) -> Self {
         let obj: Self = glib::Object::builder().build();
 
-        let make = move |args| Box::new(make_test_case(args)) as Box<dyn TestCase>;
+        let make = move |size| Box::new(make_test_case(size)) as Box<dyn TestCase>;
         let make_test_case = Box::new(make) as _;
         let _ = obj.imp().make_test_case.set(make_test_case);
 
-        anim_adjustment.connect_value_changed({
-            let obj = obj.downgrade();
-            move |adj| {
-                if let Some(obj) = obj.upgrade() {
-                    let mut clock = obj.imp().clock.borrow_mut();
-                    let instantly = adj.value() == 0.0;
-                    let rate = if instantly {
-                        1.0
-                    } else {
-                        1.0 / adj.value().max(0.001)
-                    };
-                    clock.set_rate(rate);
-                    clock.set_complete_instantly(instantly);
-                }
-            }
-        });
-
         obj
     }
 }

niri-visual-tests/src/test_window.rs

@@ -188,7 +188,7 @@ impl LayoutElement for TestWindow {
         self.inner.borrow_mut().pending_fullscreen = false;
     }
 
-    fn request_fullscreen(&mut self, _size: Size<i32, Logical>) {
+    fn request_fullscreen(&self, _size: Size<i32, Logical>) {
         self.inner.borrow_mut().pending_fullscreen = true;
     }
 
@@ -220,14 +220,8 @@ impl LayoutElement for TestWindow {
 
     fn set_active_in_column(&mut self, _active: bool) {}
 
-    fn set_floating(&mut self, _floating: bool) {}
-
     fn set_bounds(&self, _bounds: Size<i32, Logical>) {}
 
-    fn is_ignoring_opacity_window_rule(&self) -> bool {
-        false
-    }
-
     fn configure_intent(&self) -> ConfigureIntent {
         ConfigureIntent::CanSend
     }
@@ -246,10 +240,6 @@ impl LayoutElement for TestWindow {
         self.inner.borrow().requested_size
     }
 
-    fn is_child_of(&self, _parent: &Self) -> bool {
-        false
-    }
-
     fn refresh(&self) {}
 
     fn rules(&self) -> &ResolvedWindowRules {
@@ -269,7 +259,7 @@ impl LayoutElement for TestWindow {
 
     fn cancel_interactive_resize(&mut self) {}
 
-    fn on_commit(&mut self, _serial: Serial) {}
+    fn update_interactive_resize(&mut self, _serial: Serial) {}
 
     fn interactive_resize_data(&self) -> Option<InteractiveResizeData> {
         None

niri.spec.rpkg

@@ -33,6 +33,7 @@ Summary:        Scrollable-tiling Wayland compositor
 
 SourceLicense:  GPL-3.0-or-later
 
+# (MIT OR Apache-2.0) AND BSD-3-Clause
 # 0BSD OR MIT OR Apache-2.0
 # Apache-2.0
 # Apache-2.0 OR BSL-1.0
@@ -40,21 +41,18 @@ SourceLicense:  GPL-3.0-or-later
 # Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT
 # BSD-2-Clause
 # BSD-2-Clause OR Apache-2.0 OR MIT
+# BSD-3-Clause
 # BSD-3-Clause OR MIT OR Apache-2.0
 # GPL-3.0-or-later
 # ISC
 # MIT
-# MIT AND (MIT OR Apache-2.0)
 # MIT OR Apache-2.0
-# (MIT OR Apache-2.0) AND BSD-3-Clause
-# (MIT OR Apache-2.0) AND Unicode-3.0
 # MIT OR Apache-2.0 OR Zlib
 # MIT OR Zlib OR Apache-2.0
 # MPL-2.0
-# Unicode-3.0
 # Unlicense OR MIT
 # Zlib OR Apache-2.0 OR MIT
-License:        (0BSD OR MIT OR Apache-2.0) AND (Apache-2.0) AND (Apache-2.0 OR BSL-1.0) AND (Apache-2.0 OR MIT) AND (Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT) AND (BSD-2-Clause) AND (BSD-2-Clause OR Apache-2.0 OR MIT) AND (BSD-3-Clause OR MIT OR Apache-2.0) AND (GPL-3.0-or-later) AND (ISC) AND (MIT) AND (MIT AND (MIT OR Apache-2.0)) AND (MIT OR Apache-2.0) AND ((MIT OR Apache-2.0) AND BSD-3-Clause) AND ((MIT OR Apache-2.0) AND Unicode-3.0) AND (MIT OR Apache-2.0 OR Zlib) AND (MIT OR Zlib OR Apache-2.0) AND (MPL-2.0) AND (Unicode-3.0) AND (Unlicense OR MIT) AND (Zlib OR Apache-2.0 OR MIT) License:        ((MIT OR Apache-2.0) AND BSD-3-Clause) AND (0BSD OR MIT OR Apache-2.0) AND (Apache-2.0) AND (Apache-2.0 OR BSL-1.0) AND (Apache-2.0 OR MIT) AND (Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT) AND (BSD-2-Clause) AND (BSD-2-Clause OR Apache-2.0 OR MIT) AND (BSD-3-Clause) AND (BSD-3-Clause OR MIT OR Apache-2.0) AND (GPL-3.0-or-later) AND (ISC) AND (MIT) AND (MIT AND (MIT OR Apache-2.0)) AND (MIT OR Apache-2.0) AND (MIT OR Apache-2.0 OR Zlib) AND (MIT OR Zlib OR Apache-2.0) AND (MPL-2.0) AND (Unicode-3.0) AND (Unlicense OR MIT) AND (Zlib OR Apache-2.0 OR MIT)
+License:        ((MIT OR Apache-2.0) AND BSD-3-Clause) AND (0BSD OR MIT OR Apache-2.0) AND (Apache-2.0) AND (Apache-2.0 OR BSL-1.0) AND (Apache-2.0 OR MIT) AND (Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT) AND (BSD-2-Clause) AND (BSD-2-Clause OR Apache-2.0 OR MIT) AND (BSD-3-Clause) AND (BSD-3-Clause OR MIT OR Apache-2.0) AND (GPL-3.0-or-later) AND (ISC) AND (MIT) AND (MIT OR Apache-2.0) AND (MIT OR Apache-2.0 OR Zlib) AND (MIT OR Zlib OR Apache-2.0) AND (MPL-2.0) AND (Unlicense OR MIT) AND (Zlib OR Apache-2.0 OR MIT)
 # LICENSE.dependencies contains a full license breakdown
 
 URL:            https://github.com/YaLTeR/niri
@@ -103,6 +101,10 @@ Opening a new window never causes existing windows to resize.
 %prep
 {{{ git_dir_setup_macro }}}
 
+# Make the version log message look nicer: since we're building not from niri's git repository,
+# the git version macro will show its fallback string.
+sed -i 's/"unknown commit"/"%{version}"/' src/utils/mod.rs
+
 %cargo_prep -N
 
 # We're doing an online build.
@@ -111,9 +113,6 @@ sed -i 's/^offline = true$//' .cargo/config.toml
 # Final step in leaving alone our debug settings.
 sed -i 's/.*please-remove-me$//' .cargo/config.toml
 
-# Set the commit string.
-sed -i 's/\[env\]/[env]\nNIRI_BUILD_COMMIT="%{version}"/' .cargo/config.toml
-
 %build
 %cargo_build
 

resources/default-config.kdl

@@ -25,7 +25,6 @@ input {
         tap
         // dwt
         // dwtp
-        // drag-lock
         natural-scroll
         // accel-speed 0.2
         // accel-profile "flat"
@@ -192,43 +191,6 @@ layout {
         // inactive-gradient from="#505050" to="#808080" angle=45 relative-to="workspace-view"
     }
 
-    // You can enable drop shadows for windows.
-    shadow {
-        // Uncomment the next line to enable shadows.
-        // on
-
-        // By default, the shadow draws only around its window, and not behind it.
-        // Uncomment this setting to make the shadow draw behind its window.
-        //
-        // Note that niri has no way of knowing about the CSD window corner
-        // radius. It has to assume that windows have square corners, leading to
-        // shadow artifacts inside the CSD rounded corners. This setting fixes
-        // those artifacts.
-        // 
-        // However, instead you may want to set prefer-no-csd and/or
-        // geometry-corner-radius. Then, niri will know the corner radius and
-        // draw the shadow correctly, without having to draw it behind the
-        // window. These will also remove client-side shadows if the window
-        // draws any.
-        // 
-        // draw-behind-window true
-
-        // You can change how shadows look. The values below are in logical
-        // pixels and match the CSS box-shadow properties.
-
-        // Softness controls the shadow blur radius.
-        softness 30
-
-        // Spread expands the shadow.
-        spread 5
-
-        // Offset moves the shadow relative to the window.
-        offset x=0 y=5
-
-        // You can also change the shadow color and opacity.
-        color "#0007"
-    }
-
     // Struts shrink the area occupied by windows, similarly to layer-shell panels.
     // You can think of them as a kind of outer gaps. They are set in logical pixels.
     // Left and right struts will cause the next window to the side to always be visible.
@@ -288,15 +250,6 @@ window-rule {
     default-column-width {}
 }
 
-// Open the Firefox picture-in-picture player as floating by default.
-window-rule {
-    // This app-id regular expression will work for both:
-    // - host Firefox (app-id is "firefox")
-    // - Flatpak Firefox (app-id is "org.mozilla.firefox")
-    match app-id=r#"firefox$"# title="^Picture-in-Picture$"
-    open-floating true
-}
-
 // Example: block out two password managers from screen capture.
 // (This example rule is commented out with a "/-" in front.)
 /-window-rule {
@@ -488,27 +441,20 @@ binds {
     // Switches focus between the current and the previous workspace.
     // Mod+Tab { focus-workspace-previous; }
 
-    // The following binds move the focused window in and out of a column.
+    // Consume one window from the right into the focused column.
-    // If the window is alone, they will consume it into the nearby column to the side.
+    Mod+Comma  { consume-window-into-column; }
-    // If the window is already in a column, they will expel it out.
+    // Expel one window from the focused column to the right.
+    Mod+Period { expel-window-from-column; }
+
+    // There are also commands that consume or expel a single window to the side.
     Mod+BracketLeft  { consume-or-expel-window-left; }
     Mod+BracketRight { consume-or-expel-window-right; }
 
-    // Consume one window from the right to the bottom of the focused column.
-    Mod+Comma  { consume-window-into-column; }
-    // Expel the bottom window from the focused column to the right.
-    Mod+Period { expel-window-from-column; }
-
     Mod+R { switch-preset-column-width; }
     Mod+Shift+R { switch-preset-window-height; }
     Mod+Ctrl+R { reset-window-height; }
     Mod+F { maximize-column; }
     Mod+Shift+F { fullscreen-window; }
-
-    // Expand the focused column to space not taken up by other fully visible columns.
-    // Makes the column "fill the rest of the space".
-    Mod+Ctrl+F { expand-column-to-available-width; }
-
     Mod+C { center-column; }
 
     // Finer width adjustments.
@@ -526,15 +472,6 @@ binds {
     Mod+Shift+Minus { set-window-height "-10%"; }
     Mod+Shift+Equal { set-window-height "+10%"; }
 
-    // Move the focused window between the floating and the tiling layout.
-    Mod+V       { toggle-window-floating; }
-    Mod+Shift+V { switch-focus-between-floating-and-tiling; }
-
-    // Toggle tabbed column display mode.
-    // Windows in this column will appear as vertical tabs,
-    // rather than stacked on top of each other.
-    Mod+W { toggle-column-tabbed-display; }
-
     // Actions to switch layouts.
     // Note: if you uncomment these, make sure you do NOT have
     // a matching layout switch hotkey configured in xkb options above.
@@ -547,16 +484,6 @@ binds {
     Ctrl+Print { screenshot-screen; }
     Alt+Print { screenshot-window; }
 
-    // Applications such as remote-desktop clients and software KVM switches may
-    // request that niri stops processing the keyboard shortcuts defined here
-    // so they may, for example, forward the key presses as-is to a remote machine.
-    // It's a good idea to bind an escape hatch to toggle the inhibitor,
-    // so a buggy application can't hold your session hostage.
-    //
-    // The allow-inhibiting=false property can be applied to other binds as well,
-    // which ensures niri always processes them, even when an inhibitor is active.
-    Mod+Escape allow-inhibiting=false { toggle-keyboard-shortcuts-inhibit; }
-
     // The quit action will show a confirmation dialog to avoid accidental exits.
     Mod+Shift+E { quit; }
     Ctrl+Alt+Delete { quit; }

resources/niri-portals.conf

@@ -1,5 +1,4 @@
 [preferred]
 default=gnome;gtk;
 org.freedesktop.impl.portal.Access=gtk;
-org.freedesktop.impl.portal.Notification=gtk;
 org.freedesktop.impl.portal.Secret=gnome-keyring;

resources/niri-session

@@ -12,7 +12,7 @@ if [ -n "$SHELL" ] &&
 fi
 
 # Try to detect the service manager that is being used
-if hash systemctl >/dev/null 2>&1; then
+if hash systemctl &> /dev/null; then
     # Make sure there's no already running session.
     if systemctl --user -q is-active niri.service; then
       echo 'A niri session is already running.'
@@ -41,15 +41,15 @@ if hash systemctl >/dev/null 2>&1; then
 
     # Unset environment that we've set.
     systemctl --user unset-environment WAYLAND_DISPLAY XDG_SESSION_TYPE XDG_CURRENT_DESKTOP NIRI_SOCKET
-elif hash dinitctl >/dev/null 2>&1; then
+elif hash dinitctl &> /dev/null; then
     # Check that the user dinit daemon is running
-    if ! pgrep -u "$(id -u)" dinit >/dev/null 2>&1; then
+    if ! pgrep -u $(id -u) dinit &> /dev/null; then
       echo "dinit user daemon is not running."
       exit 1
     fi
 
     # Make sure there's no already running session.
-    if dinitctl --user is-started niri >/dev/null 2>&1; then
+    if dinitctl --user is-started niri &> /dev/null; then
       echo 'A niri session is already running.'
       exit 1
     fi

src/animation/clock.rs

@@ -1,202 +0,0 @@
-use std::cell::RefCell;
-use std::rc::Rc;
-use std::time::Duration;
-
-use crate::utils::get_monotonic_time;
-
-/// Shareable lazy clock that can change rate.
-///
-/// The clock will fetch the time once and then retain it until explicitly cleared with
-/// [`Clock::clear`].
-#[derive(Debug, Default, Clone)]
-pub struct Clock {
-    inner: Rc<RefCell<AdjustableClock>>,
-}
-
-#[derive(Debug, Default)]
-struct LazyClock {
-    time: Option<Duration>,
-}
-
-/// Clock that can adjust its rate.
-#[derive(Debug)]
-struct AdjustableClock {
-    inner: LazyClock,
-    current_time: Duration,
-    last_seen_time: Duration,
-    rate: f64,
-    complete_instantly: bool,
-}
-
-impl Clock {
-    /// Creates a new clock with the given time.
-    pub fn with_time(time: Duration) -> Self {
-        let clock = AdjustableClock::new(LazyClock::with_time(time));
-        Self {
-            inner: Rc::new(RefCell::new(clock)),
-        }
-    }
-
-    /// Returns the current time.
-    pub fn now(&self) -> Duration {
-        self.inner.borrow_mut().now()
-    }
-
-    /// Returns the underlying time not adjusted for rate change.
-    pub fn now_unadjusted(&self) -> Duration {
-        self.inner.borrow_mut().inner.now()
-    }
-
-    /// Sets the unadjusted clock time.
-    pub fn set_unadjusted(&mut self, time: Duration) {
-        self.inner.borrow_mut().inner.set(time);
-    }
-
-    /// Clears the stored time so it's re-fetched again next.
-    pub fn clear(&mut self) {
-        self.inner.borrow_mut().inner.clear();
-    }
-
-    /// Gets the clock rate.
-    pub fn rate(&self) -> f64 {
-        self.inner.borrow().rate()
-    }
-
-    /// Sets the clock rate.
-    pub fn set_rate(&mut self, rate: f64) {
-        self.inner.borrow_mut().set_rate(rate);
-    }
-
-    /// Returns whether animations should complete instantly.
-    pub fn should_complete_instantly(&self) -> bool {
-        self.inner.borrow().should_complete_instantly()
-    }
-
-    /// Sets whether animations should complete instantly.
-    pub fn set_complete_instantly(&mut self, value: bool) {
-        self.inner.borrow_mut().set_complete_instantly(value);
-    }
-}
-
-impl PartialEq for Clock {
-    fn eq(&self, other: &Self) -> bool {
-        Rc::ptr_eq(&self.inner, &other.inner)
-    }
-}
-
-impl Eq for Clock {}
-
-impl LazyClock {
-    pub fn with_time(time: Duration) -> Self {
-        Self { time: Some(time) }
-    }
-
-    pub fn clear(&mut self) {
-        self.time = None;
-    }
-
-    pub fn set(&mut self, time: Duration) {
-        self.time = Some(time);
-    }
-
-    pub fn now(&mut self) -> Duration {
-        *self.time.get_or_insert_with(get_monotonic_time)
-    }
-}
-
-impl AdjustableClock {
-    pub fn new(mut inner: LazyClock) -> Self {
-        let time = inner.now();
-        Self {
-            inner,
-            current_time: time,
-            last_seen_time: time,
-            rate: 1.,
-            complete_instantly: false,
-        }
-    }
-
-    pub fn rate(&self) -> f64 {
-        self.rate
-    }
-
-    pub fn set_rate(&mut self, rate: f64) {
-        self.rate = rate.clamp(0., 1000.);
-    }
-
-    pub fn should_complete_instantly(&self) -> bool {
-        self.complete_instantly
-    }
-
-    pub fn set_complete_instantly(&mut self, value: bool) {
-        self.complete_instantly = value;
-    }
-
-    pub fn now(&mut self) -> Duration {
-        let time = self.inner.now();
-
-        if self.last_seen_time == time {
-            return self.current_time;
-        }
-
-        if self.last_seen_time < time {
-            let delta = time - self.last_seen_time;
-            let delta = delta.mul_f64(self.rate);
-            self.current_time = self.current_time.saturating_add(delta);
-        } else {
-            let delta = self.last_seen_time - time;
-            let delta = delta.mul_f64(self.rate);
-            self.current_time = self.current_time.saturating_sub(delta);
-        }
-
-        self.last_seen_time = time;
-        self.current_time
-    }
-}
-
-impl Default for AdjustableClock {
-    fn default() -> Self {
-        Self::new(LazyClock::default())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn frozen_clock() {
-        let mut clock = Clock::with_time(Duration::ZERO);
-        assert_eq!(clock.now(), Duration::ZERO);
-
-        clock.set_unadjusted(Duration::from_millis(100));
-        assert_eq!(clock.now(), Duration::from_millis(100));
-
-        clock.set_unadjusted(Duration::from_millis(200));
-        assert_eq!(clock.now(), Duration::from_millis(200));
-    }
-
-    #[test]
-    fn rate_change() {
-        let mut clock = Clock::with_time(Duration::ZERO);
-        clock.set_rate(0.5);
-
-        clock.set_unadjusted(Duration::from_millis(100));
-        assert_eq!(clock.now_unadjusted(), Duration::from_millis(100));
-        assert_eq!(clock.now(), Duration::from_millis(50));
-
-        clock.set_unadjusted(Duration::from_millis(200));
-        assert_eq!(clock.now_unadjusted(), Duration::from_millis(200));
-        assert_eq!(clock.now(), Duration::from_millis(100));
-
-        clock.set_unadjusted(Duration::from_millis(150));
-        assert_eq!(clock.now_unadjusted(), Duration::from_millis(150));
-        assert_eq!(clock.now(), Duration::from_millis(75));
-
-        clock.set_rate(2.0);
-
-        clock.set_unadjusted(Duration::from_millis(250));
-        assert_eq!(clock.now_unadjusted(), Duration::from_millis(250));
-        assert_eq!(clock.now(), Duration::from_millis(275));
-    }
-}

src/animation/mod.rs

@@ -2,12 +2,14 @@ use std::time::Duration;
 
 use keyframe::functions::{EaseOutCubic, EaseOutQuad};
 use keyframe::EasingFunction;
+use portable_atomic::{AtomicF64, Ordering};
+
+use crate::utils::get_monotonic_time;
 
 mod spring;
 pub use spring::{Spring, SpringParams};
 
-mod clock;
+pub static ANIMATION_SLOWDOWN: AtomicF64 = AtomicF64::new(1.);
-pub use clock::Clock;
 
 #[derive(Debug, Clone)]
 pub struct Animation {
@@ -21,7 +23,7 @@ pub struct Animation {
     /// Best effort; not always exactly precise.
     clamped_duration: Duration,
     start_time: Duration,
-    clock: Clock,
+    current_time: Duration,
     kind: Kind,
 }
 
@@ -46,17 +48,11 @@ pub enum Curve {
 }
 
 impl Animation {
-    pub fn new(
+    pub fn new(from: f64, to: f64, initial_velocity: f64, config: niri_config::Animation) -> Self {
-        clock: Clock,
+        // Scale the velocity by slowdown to keep the touchpad gestures feeling right.
-        from: f64,
+        let initial_velocity = initial_velocity * ANIMATION_SLOWDOWN.load(Ordering::Relaxed);
-        to: f64,
-        initial_velocity: f64,
-        config: niri_config::Animation,
-    ) -> Self {
-        // Scale the velocity by rate to keep the touchpad gestures feeling right.
-        let initial_velocity = initial_velocity / clock.rate().max(0.001);
 
-        let mut rv = Self::ease(clock, from, to, initial_velocity, 0, Curve::EaseOutCubic);
+        let mut rv = Self::ease(from, to, initial_velocity, 0, Curve::EaseOutCubic);
         if config.off {
             rv.is_off = true;
             return rv;
@@ -75,6 +71,7 @@ impl Animation {
         }
 
         let start_time = self.start_time;
+        let current_time = self.current_time;
 
         match config.kind {
             niri_config::AnimationKind::Spring(p) => {
@@ -86,11 +83,10 @@ impl Animation {
                     initial_velocity: self.initial_velocity,
                     params,
                 };
-                *self = Self::spring(self.clock.clone(), spring);
+                *self = Self::spring(spring);
             }
             niri_config::AnimationKind::Easing(p) => {
                 *self = Self::ease(
-                    self.clock.clone(),
                     self.from,
                     self.to,
                     self.initial_velocity,
@@ -101,6 +97,7 @@ impl Animation {
         }
 
         self.start_time = start_time;
+        self.current_time = current_time;
     }
 
     /// Restarts the animation using the previous config.
@@ -109,12 +106,11 @@ impl Animation {
             return self.clone();
         }
 
-        // Scale the velocity by rate to keep the touchpad gestures feeling right.
+        // Scale the velocity by slowdown to keep the touchpad gestures feeling right.
-        let initial_velocity = initial_velocity / self.clock.rate().max(0.001);
+        let initial_velocity = initial_velocity * ANIMATION_SLOWDOWN.load(Ordering::Relaxed);
 
         match self.kind {
             Kind::Easing { curve } => Self::ease(
-                self.clock.clone(),
                 from,
                 to,
                 initial_velocity,
@@ -128,32 +124,23 @@ impl Animation {
                     initial_velocity: self.initial_velocity,
                     params: spring.params,
                 };
-                Self::spring(self.clock.clone(), spring)
+                Self::spring(spring)
             }
             Kind::Deceleration {
                 initial_velocity,
                 deceleration_rate,
             } => {
                 let threshold = 0.001; // FIXME
-                Self::decelerate(
+                Self::decelerate(from, initial_velocity, deceleration_rate, threshold)
-                    self.clock.clone(),
-                    from,
-                    initial_velocity,
-                    deceleration_rate,
-                    threshold,
-                )
             }
         }
     }
 
-    pub fn ease(
+    pub fn ease(from: f64, to: f64, initial_velocity: f64, duration_ms: u64, curve: Curve) -> Self {
-        clock: Clock,
+        // FIXME: ideally we shouldn't use current time here because animations started within the
-        from: f64,
+        // same frame cycle should have the same start time to be synchronized.
-        to: f64,
+        let now = get_monotonic_time();
-        initial_velocity: f64,
+
-        duration_ms: u64,
-        curve: Curve,
-    ) -> Self {
         let duration = Duration::from_millis(duration_ms);
         let kind = Kind::Easing { curve };
 
@@ -165,15 +152,19 @@ impl Animation {
             duration,
             // Our current curves never overshoot.
             clamped_duration: duration,
-            start_time: clock.now(),
+            start_time: now,
-            clock,
+            current_time: now,
             kind,
         }
     }
 
-    pub fn spring(clock: Clock, spring: Spring) -> Self {
+    pub fn spring(spring: Spring) -> Self {
         let _span = tracy_client::span!("Animation::spring");
 
+        // FIXME: ideally we shouldn't use current time here because animations started within the
+        // same frame cycle should have the same start time to be synchronized.
+        let now = get_monotonic_time();
+
         let duration = spring.duration();
         let clamped_duration = spring.clamped_duration().unwrap_or(duration);
         let kind = Kind::Spring(spring);
@@ -185,19 +176,22 @@ impl Animation {
             is_off: false,
             duration,
             clamped_duration,
-            start_time: clock.now(),
+            start_time: now,
-            clock,
+            current_time: now,
             kind,
         }
     }
 
     pub fn decelerate(
-        clock: Clock,
         from: f64,
         initial_velocity: f64,
         deceleration_rate: f64,
         threshold: f64,
     ) -> Self {
+        // FIXME: ideally we shouldn't use current time here because animations started within the
+        // same frame cycle should have the same start time to be synchronized.
+        let now = get_monotonic_time();
+
         let duration_s = if initial_velocity == 0. {
             0.
         } else {
@@ -220,26 +214,77 @@ impl Animation {
             is_off: false,
             duration,
             clamped_duration: duration,
-            start_time: clock.now(),
+            start_time: now,
-            clock,
+            current_time: now,
             kind,
         }
     }
 
-    pub fn is_done(&self) -> bool {
+    pub fn set_current_time(&mut self, time: Duration) {
-        if self.clock.should_complete_instantly() {
+        if self.duration.is_zero() {
-            return true;
+            self.current_time = time;
+            return;
         }
 
-        self.clock.now() >= self.start_time + self.duration
+        let end_time = self.start_time + self.duration;
+        if end_time <= self.current_time {
+            return;
+        }
+
+        let slowdown = ANIMATION_SLOWDOWN.load(Ordering::Relaxed);
+        if slowdown <= f64::EPSILON {
+            // Zero slowdown will cause the animation to end right away.
+            self.current_time = end_time;
+            return;
+        }
+
+        // We can't change current_time (since the incoming time values are always real-time), so
+        // apply the slowdown by shifting the start time to compensate.
+        if self.current_time <= time {
+            let delta = time - self.current_time;
+
+            let max_delta = end_time - self.current_time;
+            let min_slowdown = delta.as_secs_f64() / max_delta.as_secs_f64();
+            if slowdown <= min_slowdown {
+                // Our slowdown value will cause the animation to end right away.
+                self.current_time = end_time;
+                return;
+            }
+
+            let adjusted_delta = delta.div_f64(slowdown);
+            if adjusted_delta >= delta {
+                self.start_time -= adjusted_delta - delta;
+            } else {
+                self.start_time += delta - adjusted_delta;
+            }
+        } else {
+            let delta = self.current_time - time;
+
+            let min_slowdown = delta.as_secs_f64() / self.current_time.as_secs_f64();
+            if slowdown <= min_slowdown {
+                // Current time was about to jump to before the animation had started; let's just
+                // cancel the animation in this case.
+                self.current_time = end_time;
+                return;
+            }
+
+            let adjusted_delta = delta.div_f64(slowdown);
+            if adjusted_delta >= delta {
+                self.start_time += adjusted_delta - delta;
+            } else {
+                self.start_time -= delta - adjusted_delta;
+            }
+        }
+
+        self.current_time = time;
+    }
+
+    pub fn is_done(&self) -> bool {
+        self.current_time >= self.start_time + self.duration
     }
 
     pub fn is_clamped_done(&self) -> bool {
-        if self.clock.should_complete_instantly() {
+        self.current_time >= self.start_time + self.clamped_duration
-            return true;
-        }
-
-        self.clock.now() >= self.start_time + self.clamped_duration
     }
 
     pub fn value(&self) -> f64 {
@@ -247,7 +292,7 @@ impl Animation {
             return self.to;
         }
 
-        let passed = self.clock.now().saturating_sub(self.start_time);
+        let passed = self.current_time.saturating_sub(self.start_time);
 
         match self.kind {
             Kind::Easing { curve } => {

src/animation/spring.rs

@@ -54,10 +54,6 @@ impl Spring {
             return Duration::MAX;
         }
 
-        if (self.to - self.from).abs() <= f64::EPSILON {
-            return Duration::ZERO;
-        }
-
         let omega0 = (self.params.stiffness / self.params.mass).sqrt();
 
         // As first ansatz for the overdamped solution,
@@ -170,21 +166,3 @@ impl Spring {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn overdamped_spring_equal_from_to_nan() {
-        let spring = Spring {
-            from: 0.,
-            to: 0.,
-            initial_velocity: 0.,
-            params: SpringParams::new(1.15, 850., 0.0001),
-        };
-        let _ = spring.duration();
-        let _ = spring.clamped_duration();
-        let _ = spring.value_at(Duration::ZERO);
-    }
-}

src/backend/headless.rs

@@ -1,140 +0,0 @@
-//! Headless backend for tests.
-//!
-//! This can eventually grow into a more complete backend if needed, but for now it's missing some
-//! crucial parts like rendering.
-
-use std::mem;
-use std::sync::{Arc, Mutex};
-
-use niri_config::OutputName;
-use smithay::backend::allocator::dmabuf::Dmabuf;
-use smithay::backend::renderer::element::RenderElementStates;
-use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::output::{Mode, Output, PhysicalProperties, Subpixel};
-use smithay::reexports::wayland_protocols::wp::presentation_time::server::wp_presentation_feedback;
-use smithay::utils::Size;
-use smithay::wayland::presentation::Refresh;
-
-use super::{IpcOutputMap, OutputId, RenderResult};
-use crate::niri::{Niri, RedrawState};
-use crate::utils::{get_monotonic_time, logical_output};
-
-pub struct Headless {
-    ipc_outputs: Arc<Mutex<IpcOutputMap>>,
-}
-
-impl Headless {
-    pub fn new() -> Self {
-        Self {
-            ipc_outputs: Default::default(),
-        }
-    }
-
-    pub fn init(&mut self, _niri: &mut Niri) {}
-
-    pub fn add_output(&mut self, niri: &mut Niri, n: u8, size: (u16, u16)) {
-        let connector = format!("headless-{n}");
-        let make = "niri".to_string();
-        let model = "headless".to_string();
-        let serial = n.to_string();
-
-        let output = Output::new(
-            connector.clone(),
-            PhysicalProperties {
-                size: (0, 0).into(),
-                subpixel: Subpixel::Unknown,
-                make: make.clone(),
-                model: model.clone(),
-            },
-        );
-
-        let mode = Mode {
-            size: Size::from((i32::from(size.0), i32::from(size.1))),
-            refresh: 60_000,
-        };
-        output.change_current_state(Some(mode), None, None, None);
-        output.set_preferred(mode);
-
-        output.user_data().insert_if_missing(|| OutputName {
-            connector,
-            make: Some(make),
-            model: Some(model),
-            serial: Some(serial),
-        });
-
-        let physical_properties = output.physical_properties();
-        self.ipc_outputs.lock().unwrap().insert(
-            OutputId::next(),
-            niri_ipc::Output {
-                name: output.name(),
-                make: physical_properties.make,
-                model: physical_properties.model,
-                serial: None,
-                physical_size: None,
-                modes: vec![niri_ipc::Mode {
-                    width: size.0,
-                    height: size.1,
-                    refresh_rate: 60_000,
-                    is_preferred: true,
-                }],
-                current_mode: Some(0),
-                vrr_supported: false,
-                vrr_enabled: false,
-                logical: Some(logical_output(&output)),
-            },
-        );
-
-        niri.add_output(output, None, false);
-    }
-
-    pub fn seat_name(&self) -> String {
-        "headless".to_owned()
-    }
-
-    pub fn with_primary_renderer<T>(
-        &mut self,
-        _f: impl FnOnce(&mut GlesRenderer) -> T,
-    ) -> Option<T> {
-        None
-    }
-
-    pub fn render(&mut self, niri: &mut Niri, output: &Output) -> RenderResult {
-        let states = RenderElementStates::default();
-        let mut presentation_feedbacks = niri.take_presentation_feedbacks(output, &states);
-        presentation_feedbacks.presented::<_, smithay::utils::Monotonic>(
-            get_monotonic_time(),
-            Refresh::Unknown,
-            0,
-            wp_presentation_feedback::Kind::empty(),
-        );
-
-        let output_state = niri.output_state.get_mut(output).unwrap();
-        match mem::replace(&mut output_state.redraw_state, RedrawState::Idle) {
-            RedrawState::Idle => unreachable!(),
-            RedrawState::Queued => (),
-            RedrawState::WaitingForVBlank { .. } => unreachable!(),
-            RedrawState::WaitingForEstimatedVBlank(_) => unreachable!(),
-            RedrawState::WaitingForEstimatedVBlankAndQueued(_) => unreachable!(),
-        }
-
-        output_state.frame_callback_sequence = output_state.frame_callback_sequence.wrapping_add(1);
-
-        // FIXME: request redraw on unfinished animations remain
-
-        RenderResult::Submitted
-    }
-
-    pub fn import_dmabuf(&mut self, _dmabuf: &Dmabuf) -> bool {
-        unimplemented!()
-    }
-
-    pub fn ipc_outputs(&self) -> Arc<Mutex<IpcOutputMap>> {
-        self.ipc_outputs.clone()
-    }
-}
-
-impl Default for Headless {
-    fn default() -> Self {
-        Self::new()
-    }
-}

src/backend/mod.rs

@@ -17,13 +17,9 @@ pub use tty::Tty;
 pub mod winit;
 pub use winit::Winit;
 
-pub mod headless;
-pub use headless::Headless;
-
 pub enum Backend {
     Tty(Tty),
     Winit(Winit),
-    Headless(Headless),
 }
 
 #[derive(PartialEq, Eq)]
@@ -58,7 +54,6 @@ impl Backend {
         match self {
             Backend::Tty(tty) => tty.init(niri),
             Backend::Winit(winit) => winit.init(niri),
-            Backend::Headless(headless) => headless.init(niri),
         }
     }
 
@@ -66,7 +61,6 @@ impl Backend {
         match self {
             Backend::Tty(tty) => tty.seat_name(),
             Backend::Winit(winit) => winit.seat_name(),
-            Backend::Headless(headless) => headless.seat_name(),
         }
     }
 
@@ -77,7 +71,6 @@ impl Backend {
         match self {
             Backend::Tty(tty) => tty.with_primary_renderer(f),
             Backend::Winit(winit) => winit.with_primary_renderer(f),
-            Backend::Headless(headless) => headless.with_primary_renderer(f),
         }
     }
 
@@ -90,7 +83,6 @@ impl Backend {
         match self {
             Backend::Tty(tty) => tty.render(niri, output, target_presentation_time),
             Backend::Winit(winit) => winit.render(niri, output),
-            Backend::Headless(headless) => headless.render(niri, output),
         }
     }
 
@@ -98,7 +90,6 @@ impl Backend {
         match self {
             Backend::Tty(_) => CompositorMod::Super,
             Backend::Winit(_) => CompositorMod::Alt,
-            Backend::Headless(_) => CompositorMod::Super,
         }
     }
 
@@ -106,7 +97,6 @@ impl Backend {
         match self {
             Backend::Tty(tty) => tty.change_vt(vt),
             Backend::Winit(_) => (),
-            Backend::Headless(_) => (),
         }
     }
 
@@ -114,7 +104,6 @@ impl Backend {
         match self {
             Backend::Tty(tty) => tty.suspend(),
             Backend::Winit(_) => (),
-            Backend::Headless(_) => (),
         }
     }
 
@@ -122,7 +111,6 @@ impl Backend {
         match self {
             Backend::Tty(tty) => tty.toggle_debug_tint(),
             Backend::Winit(winit) => winit.toggle_debug_tint(),
-            Backend::Headless(_) => (),
         }
     }
 
@@ -130,7 +118,6 @@ impl Backend {
         match self {
             Backend::Tty(tty) => tty.import_dmabuf(dmabuf),
             Backend::Winit(winit) => winit.import_dmabuf(dmabuf),
-            Backend::Headless(headless) => headless.import_dmabuf(dmabuf),
         }
     }
 
@@ -138,7 +125,6 @@ impl Backend {
         match self {
             Backend::Tty(tty) => tty.early_import(surface),
             Backend::Winit(_) => (),
-            Backend::Headless(_) => (),
         }
     }
 
@@ -146,7 +132,6 @@ impl Backend {
         match self {
             Backend::Tty(tty) => tty.ipc_outputs(),
             Backend::Winit(winit) => winit.ipc_outputs(),
-            Backend::Headless(headless) => headless.ipc_outputs(),
         }
     }
 
@@ -158,7 +143,6 @@ impl Backend {
         match self {
             Backend::Tty(tty) => tty.primary_gbm_device(),
             Backend::Winit(_) => None,
-            Backend::Headless(_) => None,
         }
     }
 
@@ -166,7 +150,6 @@ impl Backend {
         match self {
             Backend::Tty(tty) => tty.set_monitors_active(active),
             Backend::Winit(_) => (),
-            Backend::Headless(_) => (),
         }
     }
 
@@ -174,7 +157,6 @@ impl Backend {
         match self {
             Backend::Tty(tty) => tty.set_output_on_demand_vrr(niri, output, enable_vrr),
             Backend::Winit(_) => (),
-            Backend::Headless(_) => (),
         }
     }
 
@@ -182,7 +164,13 @@ impl Backend {
         match self {
             Backend::Tty(tty) => tty.on_output_config_changed(niri),
             Backend::Winit(_) => (),
-            Backend::Headless(_) => (),
+        }
+    }
+
+    pub fn on_debug_config_changed(&mut self) {
+        match self {
+            Backend::Tty(tty) => tty.on_debug_config_changed(),
+            Backend::Winit(_) => (),
         }
     }
 
@@ -209,12 +197,4 @@ impl Backend {
             panic!("backend is not Winit")
         }
     }
-
-    pub fn headless(&mut self) -> &mut Headless {
-        if let Self::Headless(v) = self {
-            v
-        } else {
-            panic!("backend is not Headless")
-        }
-    }
 }

src/backend/tty.rs

@@ -18,9 +18,9 @@ use smithay::backend::allocator::dmabuf::Dmabuf;
 use smithay::backend::allocator::format::FormatSet;
 use smithay::backend::allocator::gbm::{GbmAllocator, GbmBufferFlags, GbmDevice};
 use smithay::backend::allocator::Fourcc;
-use smithay::backend::drm::compositor::{DrmCompositor, FrameFlags, PrimaryPlaneElement};
+use smithay::backend::drm::compositor::{DrmCompositor, PrimaryPlaneElement};
 use smithay::backend::drm::{
-    DrmDevice, DrmDeviceFd, DrmEvent, DrmEventMetadata, DrmEventTime, DrmNode, NodeType, VrrSupport,
+    DrmDevice, DrmDeviceFd, DrmEvent, DrmEventMetadata, DrmEventTime, DrmNode, NodeType,
 };
 use smithay::backend::egl::context::ContextPriority;
 use smithay::backend::egl::{EGLDevice, EGLDisplay};
@@ -50,7 +50,6 @@ use smithay::wayland::dmabuf::{DmabufFeedback, DmabufFeedbackBuilder, DmabufGlob
 use smithay::wayland::drm_lease::{
     DrmLease, DrmLeaseBuilder, DrmLeaseRequest, DrmLeaseState, LeaseRejected,
 };
-use smithay::wayland::presentation::Refresh;
 use smithay_drm_extras::drm_scanner::{DrmScanEvent, DrmScanner};
 use wayland_protocols::wp::linux_dmabuf::zv1::server::zwp_linux_dmabuf_feedback_v1::TrancheFlags;
 use wayland_protocols::wp::presentation_time::server::wp_presentation_feedback;
@@ -64,12 +63,7 @@ use crate::render_helpers::renderer::AsGlesRenderer;
 use crate::render_helpers::{resources, shaders, RenderTarget};
 use crate::utils::{get_monotonic_time, is_laptop_panel, logical_output};
 
-const SUPPORTED_COLOR_FORMATS: [Fourcc; 4] = [
+const SUPPORTED_COLOR_FORMATS: &[Fourcc] = &[Fourcc::Argb8888, Fourcc::Abgr8888];
-    Fourcc::Xrgb8888,
-    Fourcc::Xbgr8888,
-    Fourcc::Argb8888,
-    Fourcc::Abgr8888,
-];
 
 pub struct Tty {
     config: Rc<RefCell<Config>>,
@@ -123,7 +117,7 @@ pub struct OutputDevice {
     render_node: DrmNode,
     drm_scanner: DrmScanner,
     surfaces: HashMap<crtc::Handle, Surface>,
-    known_crtcs: HashMap<crtc::Handle, CrtcInfo>,
+    output_ids: HashMap<crtc::Handle, OutputId>,
     // SAFETY: drop after all the objects used with them are dropped.
     // See https://github.com/Smithay/smithay/issues/1102.
     drm: DrmDevice,
@@ -134,13 +128,6 @@ pub struct OutputDevice {
     active_leases: Vec<DrmLease>,
 }
 
-// A connected, but not necessarily enabled, crtc.
-#[derive(Debug, Clone)]
-pub struct CrtcInfo {
-    id: OutputId,
-    name: OutputName,
-}
-
 impl OutputDevice {
     pub fn lease_request(
         &self,
@@ -180,35 +167,6 @@ impl OutputDevice {
     pub fn remove_lease(&mut self, lease_id: u32) {
         self.active_leases.retain(|l| l.id() != lease_id);
     }
-
-    pub fn known_crtc_name(
-        &self,
-        crtc: &crtc::Handle,
-        conn: &connector::Info,
-        disable_monitor_names: bool,
-    ) -> OutputName {
-        if disable_monitor_names {
-            let conn_name = format_connector_name(conn);
-            return OutputName {
-                connector: conn_name,
-                make: None,
-                model: None,
-                serial: None,
-            };
-        }
-
-        let Some(info) = self.known_crtcs.get(crtc) else {
-            let conn_name = format_connector_name(conn);
-            error!("crtc for connector {conn_name} missing from known");
-            return OutputName {
-                connector: conn_name,
-                make: None,
-                model: None,
-                serial: None,
-            };
-        };
-        info.name.clone()
-    }
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -225,6 +183,7 @@ struct Surface {
     gamma_props: Option<GammaProps>,
     /// Gamma change to apply upon session resume.
     pending_gamma_change: Option<Option<Vec<u16>>>,
+    vrr_enabled: bool,
     /// Tracy frame that goes from vblank to vblank.
     vblank_frame: Option<tracy_client::Frame>,
     /// Frame name for the VBlank frame.
@@ -445,6 +404,8 @@ impl Tty {
                     self.device_changed(node.dev_id(), niri);
 
                     // Apply pending gamma changes and restore our existing gamma.
+                    //
+                    // Also, restore our VRR.
                     let device = self.devices.get_mut(&node).unwrap();
                     for (crtc, surface) in device.surfaces.iter_mut() {
                         if let Some(ramp) = surface.pending_gamma_change.take() {
@@ -462,6 +423,33 @@ impl Tty {
                                 warn!("error restoring gamma: {err:?}");
                             }
                         }
+
+                        // Restore VRR.
+                        let output = niri
+                            .global_space
+                            .outputs()
+                            .find(|output| {
+                                let tty_state: &TtyOutputState = output.user_data().get().unwrap();
+                                tty_state.node == node && tty_state.crtc == *crtc
+                            })
+                            .cloned();
+                        let Some(output) = output else {
+                            error!("missing output for crtc: {crtc:?}");
+                            continue;
+                        };
+                        let Some(output_state) = niri.output_state.get_mut(&output) else {
+                            error!("missing state for output {:?}", surface.name.connector);
+                            continue;
+                        };
+
+                        try_to_change_vrr(
+                            &device.drm,
+                            surface.connector,
+                            *crtc,
+                            surface,
+                            output_state,
+                            surface.vrr_enabled,
+                        );
                     }
                 }
 
@@ -478,7 +466,7 @@ impl Tty {
 
                 self.refresh_ipc_outputs(niri);
 
-                niri.notify_activity();
+                niri.idle_notifier_state.notify_activity(&niri.seat);
                 niri.monitors_active = true;
                 self.set_monitors_active(true);
                 niri.queue_redraw_all();
@@ -547,7 +535,7 @@ impl Tty {
             }
             drop(config);
 
-            niri.update_shaders();
+            niri.layout.update_shaders();
 
             // Create the dmabuf global.
             let primary_formats = renderer.dmabuf_formats();
@@ -608,7 +596,7 @@ impl Tty {
             gbm,
             drm_scanner: DrmScanner::new(),
             surfaces: HashMap::new(),
-            known_crtcs: HashMap::new(),
+            output_ids: HashMap::new(),
             drm_lease_state,
             active_leases: Vec::new(),
             non_desktop_connectors: HashSet::new(),
@@ -641,7 +629,6 @@ impl Tty {
             }
         };
 
-        let mut added = Vec::new();
         let mut removed = Vec::new();
         for event in scan_result {
             match event {
@@ -650,16 +637,16 @@ impl Tty {
                     crtc: Some(crtc),
                 } => {
                     let connector_name = format_connector_name(&connector);
-                    let name = make_output_name(&device.drm, connector.handle(), connector_name);
+                    let output_name =
+                        make_output_name(&device.drm, connector.handle(), connector_name, false);
                     debug!(
                         "new connector: {} \"{}\"",
-                        &name.connector,
+                        &output_name.connector,
-                        name.format_make_model_serial(),
+                        output_name.format_make_model_serial(),
                     );
 
                     // Assign an id to this crtc.
-                    let id = OutputId::next();
+                    device.output_ids.insert(crtc, OutputId::next());
-                    added.push((crtc, CrtcInfo { id, name }));
                 }
                 DrmScanEvent::Disconnected {
                     crtc: Some(crtc), ..
@@ -680,42 +667,11 @@ impl Tty {
         };
 
         for crtc in removed {
-            if device.known_crtcs.remove(&crtc).is_none() {
+            if device.output_ids.remove(&crtc).is_none() {
                 error!("output ID missing for disconnected crtc: {crtc:?}");
             }
         }
 
-        for (crtc, mut info) in added {
-            // Make/model/serial can match exactly between different physical monitors. This doesn't
-            // happen often, but our Layout does not support such duplicates and will panic.
-            //
-            // As a workaround, search for duplicates, and unname the new connectors if one is
-            // found. Connector names are always unique.
-            let name = &mut info.name;
-            let formatted = name.format_make_model_serial_or_connector();
-            for info in self.devices.values().flat_map(|d| d.known_crtcs.values()) {
-                if info.name.matches(&formatted) {
-                    let connector = mem::take(&mut name.connector);
-                    warn!(
-                        "new connector {connector} duplicates make/model/serial \
-                         of existing connector {}, unnaming",
-                        info.name.connector,
-                    );
-                    *name = OutputName {
-                        connector,
-                        make: None,
-                        model: None,
-                        serial: None,
-                    };
-                    break;
-                }
-            }
-
-            // Insert it right away so next added connector will check against this one too.
-            let device = self.devices.get_mut(&node).unwrap();
-            device.known_crtcs.insert(crtc, info);
-        }
-
         // This will connect any new connectors if needed, and apply other changes, such as
         // connecting back the internal laptop monitor once it becomes the only monitor left.
         //
@@ -807,8 +763,12 @@ impl Tty {
 
         let device = self.devices.get_mut(&node).context("missing device")?;
 
-        let disable_monitor_names = self.config.borrow().debug.disable_monitor_names;
+        let output_name = make_output_name(
-        let output_name = device.known_crtc_name(&crtc, &connector, disable_monitor_names);
+            &device.drm,
+            connector.handle(),
+            connector_name.clone(),
+            self.config.borrow().debug.disable_monitor_names,
+        );
 
         let non_desktop = find_drm_property(&device.drm, connector.handle(), "non-desktop")
             .and_then(|(_, info, value)| info.value_type().convert_value(value).as_boolean())
@@ -861,6 +821,45 @@ impl Tty {
             Err(err) => debug!("error setting max bpc: {err:?}"),
         }
 
+        // Try to enable VRR if requested.
+        let mut vrr_enabled = false;
+        if let Some(capable) = is_vrr_capable(&device.drm, connector.handle()) {
+            if capable {
+                // Even if on-demand, we still disable it until later checks.
+                let vrr = config.is_vrr_always_on();
+                let word = if vrr { "enabling" } else { "disabling" };
+
+                match set_vrr_enabled(&device.drm, crtc, vrr) {
+                    Ok(enabled) => {
+                        if enabled != vrr {
+                            warn!("failed {} VRR", word);
+                        }
+
+                        vrr_enabled = enabled;
+                    }
+                    Err(err) => {
+                        warn!("error {} VRR: {err:?}", word);
+                    }
+                }
+            } else {
+                if !config.is_vrr_always_off() {
+                    warn!("cannot enable VRR because connector is not vrr_capable");
+                }
+
+                // Try to disable it anyway to work around a bug where resetting DRM state causes
+                // vrr_capable to be reset to 0, potentially leaving VRR_ENABLED at 1.
+                let res = set_vrr_enabled(&device.drm, crtc, false);
+                if matches!(res, Ok(true)) {
+                    warn!("error disabling VRR");
+
+                    // So that we can try it again later.
+                    vrr_enabled = true;
+                }
+            }
+        } else if !config.is_vrr_always_off() {
+            warn!("cannot enable VRR because connector is not vrr_capable");
+        }
+
         let mut gamma_props = GammaProps::new(&device.drm, crtc)
             .map_err(|err| debug!("error getting gamma properties: {err:?}"))
             .ok();
@@ -879,31 +878,6 @@ impl Tty {
             .drm
             .create_surface(crtc, mode, &[connector.handle()])?;
 
-        // Try to enable VRR if requested.
-        match surface.vrr_supported(connector.handle()) {
-            Ok(VrrSupport::Supported | VrrSupport::RequiresModeset) => {
-                // Even if on-demand, we still disable it until later checks.
-                let vrr = config.is_vrr_always_on();
-                let word = if vrr { "enabling" } else { "disabling" };
-
-                if let Err(err) = surface.use_vrr(vrr) {
-                    warn!("error {} VRR: {err:?}", word);
-                }
-            }
-            Ok(VrrSupport::NotSupported) => {
-                if !config.is_vrr_always_off() {
-                    warn!("cannot enable VRR because connector does not support it");
-                }
-
-                // Try to disable it anyway to work around a bug where resetting DRM state causes
-                // vrr_capable to be reset to 0, potentially leaving VRR_ENABLED at 1.
-                let _ = surface.use_vrr(false);
-            }
-            Err(err) => {
-                warn!("error querying for VRR support: {err:?}");
-            }
-        }
-
         // Create GBM allocator.
         let gbm_flags = GbmBufferFlags::RENDERING | GbmBufferFlags::SCANOUT;
         let allocator = GbmAllocator::new(device.gbm.clone(), gbm_flags);
@@ -930,6 +904,23 @@ impl Tty {
             .insert_if_missing(|| TtyOutputState { node, crtc });
         output.user_data().insert_if_missing(|| output_name.clone());
 
+        let mut planes = surface.planes().clone();
+
+        let config = self.config.borrow();
+
+        // Overlay planes are disabled by default as they cause weird performance issues on my
+        // system.
+        if !config.debug.enable_overlay_planes {
+            planes.overlay.clear();
+        }
+
+        // Cursor planes have bugs on some systems.
+        let cursor_plane_gbm = if config.debug.disable_cursor_plane {
+            None
+        } else {
+            Some(device.gbm.clone())
+        };
+
         let renderer = self.gpu_manager.single_renderer(&device.render_node)?;
         let egl_context = renderer.as_ref().egl_context();
         let render_formats = egl_context.dmabuf_render_formats();
@@ -968,7 +959,7 @@ impl Tty {
         let res = DrmCompositor::new(
             OutputModeSource::Auto(output.clone()),
             surface,
-            None,
+            Some(planes),
             allocator.clone(),
             device.gbm.clone(),
             SUPPORTED_COLOR_FORMATS,
@@ -976,7 +967,7 @@ impl Tty {
             // formats, even though we only ever render on the primary GPU.
             render_formats.clone(),
             device.drm.cursor_size(),
-            Some(device.gbm.clone()),
+            cursor_plane_gbm.clone(),
         );
 
         let mut compositor = match res {
@@ -994,17 +985,21 @@ impl Tty {
                 let surface = device
                     .drm
                     .create_surface(crtc, mode, &[connector.handle()])?;
+                let mut planes = surface.planes().clone();
+                if !config.debug.enable_overlay_planes {
+                    planes.overlay.clear();
+                }
 
                 DrmCompositor::new(
                     OutputModeSource::Auto(output.clone()),
                     surface,
-                    None,
+                    Some(planes),
                     allocator,
                     device.gbm.clone(),
                     SUPPORTED_COLOR_FORMATS,
                     render_formats,
                     device.drm.cursor_size(),
-                    Some(device.gbm.clone()),
+                    cursor_plane_gbm,
                 )
                 .context("error creating DRM compositor")?
             }
@@ -1013,6 +1008,7 @@ impl Tty {
         if self.debug_tint {
             compositor.set_debug_flags(DebugFlags::TINT);
         }
+        compositor.use_direct_scanout(!config.debug.disable_direct_scanout);
 
         let mut dmabuf_feedback = None;
         if let Ok(primary_renderer) = self.gpu_manager.single_renderer(&self.primary_render_node) {
@@ -1041,8 +1037,6 @@ impl Tty {
             }
         }
 
-        let vrr_enabled = compositor.vrr_enabled();
-
         let vblank_frame_name =
             tracy_client::FrameName::new_leak(format!("vblank on {connector_name}"));
         let time_since_presentation_plot_name = tracy_client::PlotName::new_leak(format!(
@@ -1060,6 +1054,7 @@ impl Tty {
             compositor,
             dmabuf_feedback,
             gamma_props,
+            vrr_enabled,
             pending_gamma_change: None,
             vblank_frame: None,
             vblank_frame_name,
@@ -1238,17 +1233,10 @@ impl Tty {
         // Mark the last frame as submitted.
         match surface.compositor.frame_submitted() {
             Ok(Some((mut feedback, target_presentation_time))) => {
-                let refresh = match output_state.frame_clock.refresh_interval() {
+                let refresh = output_state
-                    Some(refresh) => {
+                    .frame_clock
-                        if output_state.frame_clock.vrr() {
+                    .refresh_interval()
-                            Refresh::Variable(refresh)
+                    .unwrap_or(Duration::ZERO);
-                        } else {
-                            Refresh::Fixed(refresh)
-                        }
-                    }
-                    None => Refresh::Unknown,
-                };
-
                 // FIXME: ideally should be monotonically increasing for a surface.
                 let seq = meta.sequence as u64;
                 let mut flags = wp_presentation_feedback::Kind::Vsync
@@ -1398,35 +1386,9 @@ impl Tty {
             draw_damage(&mut output_state.debug_damage_tracker, &mut elements);
         }
 
-        // Overlay planes are disabled by default as they cause weird performance issues on my
-        // system.
-        let flags = {
-            let debug = &self.config.borrow().debug;
-
-            let primary_scanout_flag = if debug.restrict_primary_scanout_to_matching_format {
-                FrameFlags::ALLOW_PRIMARY_PLANE_SCANOUT
-            } else {
-                FrameFlags::ALLOW_PRIMARY_PLANE_SCANOUT_ANY
-            };
-            let mut flags = primary_scanout_flag | FrameFlags::ALLOW_CURSOR_PLANE_SCANOUT;
-
-            if debug.enable_overlay_planes {
-                flags.insert(FrameFlags::ALLOW_OVERLAY_PLANE_SCANOUT);
-            }
-            if debug.disable_direct_scanout {
-                flags.remove(primary_scanout_flag);
-                flags.remove(FrameFlags::ALLOW_OVERLAY_PLANE_SCANOUT);
-            }
-            if debug.disable_cursor_plane {
-                flags.remove(FrameFlags::ALLOW_CURSOR_PLANE_SCANOUT);
-            }
-
-            flags
-        };
-
         // Hand them over to the DRM.
         let drm_compositor = &mut surface.compositor;
-        match drm_compositor.render_frame::<_, _>(&mut renderer, &elements, [0.; 4], flags) {
+        match drm_compositor.render_frame::<_, _>(&mut renderer, &elements, [0.; 4]) {
             Ok(res) => {
                 let needs_sync = res.needs_sync()
                     || self
@@ -1607,13 +1569,17 @@ impl Tty {
         let _span = tracy_client::span!("Tty::refresh_ipc_outputs");
 
         let mut ipc_outputs = HashMap::new();
-        let disable_monitor_names = self.config.borrow().debug.disable_monitor_names;
 
         for (node, device) in &self.devices {
             for (connector, crtc) in device.drm_scanner.crtcs() {
                 let connector_name = format_connector_name(connector);
                 let physical_size = connector.size();
-                let output_name = device.known_crtc_name(&crtc, connector, disable_monitor_names);
+                let output_name = make_output_name(
+                    &device.drm,
+                    connector.handle(),
+                    connector_name.clone(),
+                    self.config.borrow().debug.disable_monitor_names,
+                );
 
                 let surface = device.surfaces.get(&crtc);
                 let current_crtc_mode = surface.map(|surface| surface.compositor.pending_mode());
@@ -1648,17 +1614,8 @@ impl Tty {
                     }
                 }
 
-                let vrr_supported = surface
+                let vrr_supported = is_vrr_capable(&device.drm, connector.handle()) == Some(true);
-                    .map(|surface| {
+                let vrr_enabled = surface.map_or(false, |surface| surface.vrr_enabled);
-                        matches!(
-                            surface.compositor.vrr_supported(connector.handle()),
-                            Ok(VrrSupport::Supported | VrrSupport::RequiresModeset)
-                        )
-                    })
-                    .unwrap_or_else(|| {
-                        is_vrr_capable(&device.drm, connector.handle()) == Some(true)
-                    });
-                let vrr_enabled = surface.is_some_and(|surface| surface.compositor.vrr_enabled());
 
                 let logical = niri
                     .global_space
@@ -1669,12 +1626,6 @@ impl Tty {
                     })
                     .map(logical_output);
 
-                let id = device.known_crtcs.get(&crtc).map(|info| info.id);
-                let id = id.unwrap_or_else(|| {
-                    error!("crtc for connector {connector_name} missing from known");
-                    OutputId::next()
-                });
-
                 let ipc_output = niri_ipc::Output {
                     name: connector_name,
                     make: output_name.make.unwrap_or_else(|| "Unknown".into()),
@@ -1688,6 +1639,10 @@ impl Tty {
                     logical,
                 };
 
+                let id = device.output_ids.get(&crtc).copied().unwrap_or_else(|| {
+                    error!("output ID missing for crtc: {crtc:?}");
+                    OutputId::next()
+                });
                 ipc_outputs.insert(id, ipc_output);
             }
         }
@@ -1745,17 +1700,14 @@ impl Tty {
             for (&crtc, surface) in device.surfaces.iter_mut() {
                 let tty_state: &TtyOutputState = output.user_data().get().unwrap();
                 if tty_state.node == node && tty_state.crtc == crtc {
-                    let word = if enable_vrr { "enabling" } else { "disabling" };
+                    try_to_change_vrr(
-                    if let Err(err) = surface.compositor.use_vrr(enable_vrr) {
+                        &device.drm,
-                        warn!(
+                        surface.connector,
-                            "output {:?}: error {} VRR: {err:?}",
+                        crtc,
-                            surface.name.connector, word
+                        surface,
+                        output_state,
+                        enable_vrr,
                     );
-                    }
-                    output_state
-                        .frame_clock
-                        .set_vrr(surface.compositor.vrr_enabled());
-
                     self.refresh_ipc_outputs(niri);
                     return;
                 }
@@ -1821,11 +1773,8 @@ impl Tty {
                 };
 
                 let change_mode = surface.compositor.pending_mode() != mode;
-
+                let change_always_vrr = surface.vrr_enabled != config.is_vrr_always_on();
-                let vrr_enabled = surface.compositor.vrr_enabled();
-                let change_always_vrr = vrr_enabled != config.is_vrr_always_on();
                 let is_on_demand_vrr = config.is_vrr_on_demand();
-
                 if !change_mode && !change_always_vrr && !is_on_demand_vrr {
                     continue;
                 }
@@ -1847,21 +1796,18 @@ impl Tty {
                     continue;
                 };
 
-                if (is_on_demand_vrr && vrr_enabled != output_state.on_demand_vrr_enabled)
+                if (is_on_demand_vrr && surface.vrr_enabled != output_state.on_demand_vrr_enabled)
                     || (!is_on_demand_vrr && change_always_vrr)
                 {
-                    let vrr = !vrr_enabled;
+                    try_to_change_vrr(
-                    let word = if vrr { "enabling" } else { "disabling" };
+                        &device.drm,
-                    if let Err(err) = surface.compositor.use_vrr(vrr) {
+                        connector.handle(),
-                        warn!(
+                        crtc,
-                            "output {:?}: error {} VRR: {err:?}",
+                        surface,
-                            surface.name.connector, word
+                        output_state,
+                        !surface.vrr_enabled,
                     );
                 }
-                    output_state
-                        .frame_clock
-                        .set_vrr(surface.compositor.vrr_enabled());
-                }
 
                 if change_mode {
                     if fallback {
@@ -1892,17 +1838,12 @@ impl Tty {
                     let wl_mode = Mode::from(mode);
                     output.change_current_state(Some(wl_mode), None, None, None);
                     output.set_preferred(wl_mode);
-                    output_state.frame_clock = FrameClock::new(
+                    output_state.frame_clock =
-                        Some(refresh_interval(mode)),
+                        FrameClock::new(Some(refresh_interval(mode)), surface.vrr_enabled);
-                        surface.compositor.vrr_enabled(),
-                    );
                     niri.output_resized(&output);
                 }
             }
 
-            let config = self.config.borrow();
-            let disable_monitor_names = config.debug.disable_monitor_names;
-
             for (connector, crtc) in device.drm_scanner.crtcs() {
                 // Check if connected.
                 if connector.state() != connector::State::Connected {
@@ -1918,9 +1859,16 @@ impl Tty {
                     continue;
                 }
 
-                let output_name = device.known_crtc_name(&crtc, connector, disable_monitor_names);
+                let connector_name = format_connector_name(connector);
-
+                let output_name = make_output_name(
-                let config = config
+                    &device.drm,
+                    connector.handle(),
+                    connector_name,
+                    self.config.borrow().debug.disable_monitor_names,
+                );
+                let config = self
+                    .config
+                    .borrow()
                     .outputs
                     .find(&output_name)
                     .cloned()
@@ -1949,12 +1897,24 @@ impl Tty {
         self.refresh_ipc_outputs(niri);
     }
 
+    pub fn on_debug_config_changed(&mut self) {
+        let config = self.config.borrow();
+        let debug = &config.debug;
+        let use_direct_scanout = !debug.disable_direct_scanout;
+
+        // FIXME: reload other flags if possible?
+        for device in self.devices.values_mut() {
+            for surface in device.surfaces.values_mut() {
+                surface.compositor.use_direct_scanout(use_direct_scanout);
+            }
+        }
+    }
+
     pub fn get_device_from_node(&mut self, node: DrmNode) -> Option<&mut OutputDevice> {
         self.devices.get_mut(&node)
     }
 
     pub fn disconnected_connector_name_by_name_match(&self, target: &str) -> Option<OutputName> {
-        let disable_monitor_names = self.config.borrow().debug.disable_monitor_names;
         for device in self.devices.values() {
             for (connector, crtc) in device.drm_scanner.crtcs() {
                 // Check if connected.
@@ -1971,7 +1931,13 @@ impl Tty {
                     continue;
                 }
 
-                let output_name = device.known_crtc_name(&crtc, connector, disable_monitor_names);
+                let connector_name = format_connector_name(connector);
+                let output_name = make_output_name(
+                    &device.drm,
+                    connector.handle(),
+                    connector_name,
+                    self.config.borrow().debug.disable_monitor_names,
+                );
                 if output_name.matches(target) {
                     return Some(output_name);
                 }
@@ -2166,8 +2132,9 @@ fn surface_dmabuf_feedback(
     let surface = compositor.surface();
     let planes = surface.planes();
 
-    let primary_plane_formats = surface.plane_info().formats.clone();
+    let plane_formats = surface
-    let primary_or_overlay_plane_formats = primary_plane_formats
+        .plane_info()
+        .formats
         .iter()
         .chain(planes.overlay.iter().flat_map(|p| p.formats.iter()))
         .copied()
@@ -2175,11 +2142,7 @@ fn surface_dmabuf_feedback(
 
     // We limit the scan-out trache to formats we can also render from so that there is always a
     // fallback render path available in case the supplied buffer can not be scanned out directly.
-    let mut primary_scanout_formats = primary_plane_formats
+    let mut scanout_formats = plane_formats
-        .intersection(&primary_formats)
-        .copied()
-        .collect::<Vec<_>>();
-    let mut primary_or_overlay_scanout_formats = primary_or_overlay_plane_formats
         .intersection(&primary_formats)
         .copied()
         .collect::<Vec<_>>();
@@ -2187,32 +2150,17 @@ fn surface_dmabuf_feedback(
     // HACK: AMD iGPU + dGPU systems share some modifiers between the two, and yet cross-device
     // buffers produce a glitched scanout if the modifier is not Linear...
     if primary_render_node != surface_render_node {
-        primary_scanout_formats.retain(|f| f.modifier == Modifier::Linear);
+        scanout_formats.retain(|f| f.modifier == Modifier::Linear);
-        primary_or_overlay_scanout_formats.retain(|f| f.modifier == Modifier::Linear);
     }
 
     let builder = DmabufFeedbackBuilder::new(primary_render_node.dev_id(), primary_formats);
 
-    trace!(
-        "primary scanout formats: {}, overlay adds: {}",
-        primary_scanout_formats.len(),
-        primary_or_overlay_scanout_formats.len() - primary_scanout_formats.len(),
-    );
-
-    // Prefer the primary-plane-only formats, then primary-or-overlay-plane formats. This will
-    // increase the chance of scanning out a client even with our disabled-by-default overlay
-    // planes.
     let scanout = builder
         .clone()
         .add_preference_tranche(
             surface_render_node.dev_id(),
             Some(TrancheFlags::Scanout),
-            primary_scanout_formats,
+            scanout_formats,
-        )
-        .add_preference_tranche(
-            surface_render_node.dev_id(),
-            Some(TrancheFlags::Scanout),
-            primary_or_overlay_scanout_formats,
         )
         .build()?;
 
@@ -2475,6 +2423,24 @@ fn is_vrr_capable(device: &DrmDevice, connector: connector::Handle) -> Option<bo
     info.value_type().convert_value(value).as_boolean()
 }
 
+fn set_vrr_enabled(device: &DrmDevice, crtc: crtc::Handle, enabled: bool) -> anyhow::Result<bool> {
+    let (prop, info, _) =
+        find_drm_property(device, crtc, "VRR_ENABLED").context("VRR_ENABLED property missing")?;
+
+    let value = property::Value::UnsignedRange(if enabled { 1 } else { 0 });
+    device
+        .set_property(crtc, prop, value.into())
+        .context("error setting VRR_ENABLED property")?;
+
+    let value = get_drm_property(device, crtc, prop)
+        .context("VRR_ENABLED property missing after setting")?;
+    match info.value_type().convert_value(value) {
+        property::Value::UnsignedRange(value) => Ok(value == 1),
+        property::Value::Boolean(value) => Ok(value),
+        _ => bail!("wrong VRR_ENABLED property type"),
+    }
+}
+
 pub fn set_gamma_for_crtc(
     device: &DrmDevice,
     crtc: crtc::Handle,
@@ -2520,6 +2486,43 @@ pub fn set_gamma_for_crtc(
     Ok(())
 }
 
+fn try_to_change_vrr(
+    device: &DrmDevice,
+    connector: connector::Handle,
+    crtc: crtc::Handle,
+    surface: &mut Surface,
+    output_state: &mut crate::niri::OutputState,
+    enable_vrr: bool,
+) {
+    let _span = tracy_client::span!("try_to_change_vrr");
+
+    if is_vrr_capable(device, connector) == Some(true) {
+        let word = if enable_vrr { "enabling" } else { "disabling" };
+
+        match set_vrr_enabled(device, crtc, enable_vrr) {
+            Ok(enabled) => {
+                if enabled != enable_vrr {
+                    warn!("output {:?}: failed {} VRR", surface.name.connector, word);
+                }
+
+                surface.vrr_enabled = enabled;
+                output_state.frame_clock.set_vrr(enabled);
+            }
+            Err(err) => {
+                warn!(
+                    "output {:?}: error {} VRR: {err:?}",
+                    surface.name.connector, word
+                );
+            }
+        }
+    } else if enable_vrr {
+        warn!(
+            "output {:?}: cannot enable VRR because connector is not vrr_capable",
+            surface.name.connector
+        );
+    }
+}
+
 fn format_connector_name(connector: &connector::Info) -> String {
     format!(
         "{}-{}",
@@ -2532,7 +2535,17 @@ fn make_output_name(
     device: &DrmDevice,
     connector: connector::Handle,
     connector_name: String,
+    disable_monitor_names: bool,
 ) -> OutputName {
+    if disable_monitor_names {
+        return OutputName {
+            connector: connector_name,
+            make: None,
+            model: None,
+            serial: None,
+        };
+    }
+
     let info = get_edid_info(device, connector)
         .map_err(|err| warn!("error getting EDID info for {connector_name}: {err:?}"))
         .ok();

src/backend/winit.rs

@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use std::mem;
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};
+use std::time::Duration;
 
 use niri_config::{Config, OutputName};
 use smithay::backend::allocator::dmabuf::Dmabuf;
@@ -15,7 +16,6 @@ use smithay::reexports::calloop::LoopHandle;
 use smithay::reexports::wayland_protocols::wp::presentation_time::server::wp_presentation_feedback;
 use smithay::reexports::winit::dpi::LogicalSize;
 use smithay::reexports::winit::window::Window;
-use smithay::wayland::presentation::Refresh;
 
 use super::{IpcOutputMap, OutputId, RenderResult};
 use crate::niri::{Niri, RedrawState, State};
@@ -156,7 +156,7 @@ impl Winit {
         }
         drop(config);
 
-        niri.update_shaders();
+        niri.layout.update_shaders();
 
         niri.add_output(self.output.clone(), None, false);
     }
@@ -216,9 +216,11 @@ impl Winit {
             self.backend.submit(Some(damage)).unwrap();
 
             let mut presentation_feedbacks = niri.take_presentation_feedbacks(output, &res.states);
+            let mode = output.current_mode().unwrap();
+            let refresh = Duration::from_secs_f64(1_000f64 / mode.refresh as f64);
             presentation_feedbacks.presented::<_, smithay::utils::Monotonic>(
                 get_monotonic_time(),
-                Refresh::Unknown,
+                refresh,
                 0,
                 wp_presentation_feedback::Kind::empty(),
             );

src/cli.rs

@@ -64,8 +64,6 @@ pub enum Msg {
     Workspaces,
     /// List open windows.
     Windows,
-    /// List open layer-shell surfaces.
-    Layers,
     /// Get the configured keyboard layouts.
     KeyboardLayouts,
     /// Print information about the focused output.

src/cursor.rs

@@ -4,11 +4,12 @@ use std::env;
 use std::fs::File;
 use std::io::Read;
 use std::rc::Rc;
+use std::sync::Mutex;
 
 use anyhow::{anyhow, Context};
 use smithay::backend::allocator::Fourcc;
 use smithay::backend::renderer::element::memory::MemoryRenderBuffer;
-use smithay::input::pointer::{CursorIcon, CursorImageStatus, CursorImageSurfaceData};
+use smithay::input::pointer::{CursorIcon, CursorImageAttributes, CursorImageStatus};
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::utils::{IsAlive, Logical, Physical, Point, Transform};
 use smithay::wayland::compositor::with_states;
@@ -66,7 +67,7 @@ impl CursorManager {
                 let hotspot = with_states(&surface, |states| {
                     states
                         .data_map
-                        .get::<CursorImageSurfaceData>()
+                        .get::<Mutex<CursorImageAttributes>>()
                         .unwrap()
                         .lock()
                         .unwrap()

src/dbus/freedesktop_screensaver.rs

@@ -6,10 +6,9 @@ use std::sync::{Arc, Mutex, OnceLock};
 use anyhow::Context;
 use futures_util::StreamExt;
 use zbus::fdo::{self, RequestNameFlags};
-use zbus::message::Header;
 use zbus::names::{OwnedUniqueName, UniqueName};
 use zbus::zvariant::NoneValue;
-use zbus::{interface, Task};
+use zbus::{dbus_interface, MessageHeader, Task};
 
 use super::Start;
 
@@ -21,11 +20,11 @@ pub struct ScreenSaver {
     monitor_task: Arc<OnceLock<Task<()>>>,
 }
 
-#[interface(name = "org.freedesktop.ScreenSaver")]
+#[dbus_interface(name = "org.freedesktop.ScreenSaver")]
 impl ScreenSaver {
     async fn inhibit(
         &mut self,
-        #[zbus(header)] hdr: Header<'_>,
+        #[zbus(header)] hdr: MessageHeader<'_>,
         application_name: &str,
         reason_for_inhibit: &str,
     ) -> fdo::Result<u32> {
@@ -34,7 +33,7 @@ impl ScreenSaver {
             hdr.sender()
         );
 
-        let Some(name) = hdr.sender() else {
+        let Ok(Some(name)) = hdr.sender() else {
             return Err(fdo::Error::Failed(String::from("no sender")));
         };
         let name = OwnedUniqueName::from(name.to_owned());

src/dbus/gnome_shell_introspect.rs

@@ -1,9 +1,8 @@
 use std::collections::HashMap;
 
 use zbus::fdo::{self, RequestNameFlags};
-use zbus::interface;
-use zbus::object_server::SignalEmitter;
 use zbus::zvariant::{SerializeDict, Type, Value};
+use zbus::{dbus_interface, SignalContext};
 
 use super::Start;
 
@@ -34,7 +33,7 @@ pub struct WindowProperties {
     pub app_id: String,
 }
 
-#[interface(name = "org.gnome.Shell.Introspect")]
+#[dbus_interface(name = "org.gnome.Shell.Introspect")]
 impl Introspect {
     async fn get_windows(&self) -> fdo::Result<HashMap<u64, WindowProperties>> {
         if let Err(err) = self.to_niri.send(IntrospectToNiri::GetWindows) {
@@ -53,8 +52,8 @@ impl Introspect {
 
     // FIXME: call this upon window changes, once more of the infrastructure is there (will be
     // needed for the event stream IPC anyway).
-    #[zbus(signal)]
+    #[dbus_interface(signal)]
-    pub async fn windows_changed(ctxt: &SignalEmitter<'_>) -> zbus::Result<()>;
+    pub async fn windows_changed(ctxt: &SignalContext<'_>) -> zbus::Result<()>;
 }
 
 impl Introspect {

src/dbus/gnome_shell_screenshot.rs

@@ -1,7 +1,7 @@
 use std::path::PathBuf;
 
+use zbus::dbus_interface;
 use zbus::fdo::{self, RequestNameFlags};
-use zbus::interface;
 
 use super::Start;
 
@@ -18,7 +18,7 @@ pub enum NiriToScreenshot {
     ScreenshotResult(Option<PathBuf>),
 }
 
-#[interface(name = "org.gnome.Shell.Screenshot")]
+#[dbus_interface(name = "org.gnome.Shell.Screenshot")]
 impl Screenshot {
     async fn screenshot(
         &self,

src/dbus/mod.rs

@@ -1,5 +1,5 @@
 use zbus::blocking::Connection;
-use zbus::object_server::Interface;
+use zbus::Interface;
 
 use crate::niri::State;
 
@@ -45,39 +45,12 @@ impl DBusServers {
         let mut dbus = Self::default();
 
         if is_session_instance {
-            let (to_niri, from_service_channel) = calloop::channel::channel();
+            let service_channel = ServiceChannel::new(niri.display_handle.clone());
-            let service_channel = ServiceChannel::new(to_niri);
-            niri.event_loop
-                .insert_source(from_service_channel, move |event, _, state| match event {
-                    calloop::channel::Event::Msg(new_client) => {
-                        state.niri.insert_client(new_client);
-                    }
-                    calloop::channel::Event::Closed => (),
-                })
-                .unwrap();
             dbus.conn_service_channel = try_start(service_channel);
         }
 
         if is_session_instance || config.debug.dbus_interfaces_in_non_session_instances {
-            let (to_niri, from_display_config) = calloop::channel::channel();
+            let display_config = DisplayConfig::new(backend.ipc_outputs());
-            let display_config = DisplayConfig::new(to_niri, backend.ipc_outputs());
-            niri.event_loop
-                .insert_source(from_display_config, move |event, _, state| match event {
-                    calloop::channel::Event::Msg(new_conf) => {
-                        for (name, conf) in new_conf {
-                            state.modify_output_config(&name, move |output| {
-                                if let Some(new_output) = conf {
-                                    *output = new_output;
-                                } else {
-                                    output.off = true;
-                                }
-                            });
-                        }
-                        state.reload_output_config();
-                    }
-                    calloop::channel::Event::Closed => (),
-                })
-                .unwrap();
             dbus.conn_display_config = try_start(display_config);
 
             let screen_saver = ScreenSaver::new(niri.is_fdo_idle_inhibited.clone());
@@ -110,7 +83,7 @@ impl DBusServers {
             dbus.conn_introspect = try_start(introspect);
 
             #[cfg(feature = "xdp-gnome-screencast")]
-            {
+            if niri.pipewire.is_some() {
                 let (to_niri, from_screen_cast) = calloop::channel::channel();
                 niri.event_loop
                     .insert_source(from_screen_cast, {
@@ -122,6 +95,8 @@ impl DBusServers {
                     .unwrap();
                 let screen_cast = ScreenCast::new(backend.ipc_outputs(), to_niri);
                 dbus.conn_screen_cast = try_start(screen_cast);
+            } else {
+                warn!("disabling screencast support because we couldn't start PipeWire");
             }
         }
 

src/dbus/mutter_display_config.rs

@@ -1,21 +1,16 @@
 use std::collections::HashMap;
-use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
-use smithay::utils::Size;
 use zbus::fdo::RequestNameFlags;
-use zbus::object_server::SignalEmitter;
 use zbus::zvariant::{self, OwnedValue, Type};
-use zbus::{fdo, interface};
+use zbus::{dbus_interface, fdo, SignalContext};
 
 use super::Start;
 use crate::backend::IpcOutputMap;
 use crate::utils::is_laptop_panel;
-use crate::utils::scale::supported_scales;
 
 pub struct DisplayConfig {
-    to_niri: calloop::channel::Sender<HashMap<String, Option<niri_config::Output>>>,
     ipc_outputs: Arc<Mutex<IpcOutputMap>>,
 }
 
@@ -48,18 +43,7 @@ pub struct LogicalMonitor {
     properties: HashMap<String, OwnedValue>,
 }
 
-// ApplyMonitorsConfig
+#[dbus_interface(name = "org.gnome.Mutter.DisplayConfig")]
-#[derive(Deserialize, Type)]
-pub struct LogicalMonitorConfiguration {
-    x: i32,
-    y: i32,
-    scale: f64,
-    transform: u32,
-    _is_primary: bool,
-    monitors: Vec<(String, String, HashMap<String, OwnedValue>)>,
-}
-
-#[interface(name = "org.gnome.Mutter.DisplayConfig")]
 impl DisplayConfig {
     async fn get_current_state(
         &self,
@@ -70,10 +54,14 @@ impl DisplayConfig {
         HashMap<String, OwnedValue>,
     )> {
         // Construct the DBus response.
-        let mut monitors = Vec::new();
+        let mut monitors: Vec<(Monitor, LogicalMonitor)> = self
-        let mut logical_monitors = Vec::new();
+            .ipc_outputs
-
+            .lock()
-        for output in self.ipc_outputs.lock().unwrap().values() {
+            .unwrap()
+            .values()
+            // Take only enabled outputs.
+            .filter(|output| output.current_mode.is_some() && output.logical.is_some())
+            .map(|output| {
                 // Loosely matches the check in Mutter.
                 let c = &output.name;
                 let is_laptop_panel = is_laptop_panel(c);
@@ -99,17 +87,15 @@ impl DisplayConfig {
                             refresh_rate,
                             is_preferred,
                         } = *m;
-                    let width = i32::from(width);
+                        let refresh = refresh_rate as f64 / 1000.;
-                    let height = i32::from(height);
-                    let refresh_rate = refresh_rate as f64 / 1000.;
 
                         Mode {
-                        id: format!("{width}x{height}@{refresh_rate:.3}"),
+                            id: format!("{width}x{height}@{refresh:.3}"),
-                        width,
+                            width: i32::from(width),
-                        height,
+                            height: i32::from(height),
-                        refresh_rate,
+                            refresh_rate: refresh,
                             preferred_scale: 1.,
-                        supported_scales: supported_scales(Size::from((width, height))).collect(),
+                            supported_scales: vec![1., 2., 3.],
                             properties: HashMap::from([(
                                 String::from("is-preferred"),
                                 OwnedValue::from(is_preferred),
@@ -117,11 +103,9 @@ impl DisplayConfig {
                         }
                     })
                     .collect();
-            if let Some(mode) = output.current_mode {
+                modes[output.current_mode.unwrap()]
-                modes[mode]
                     .properties
                     .insert(String::from("is-current"), OwnedValue::from(true));
-            }
 
                 let connector = c.clone();
                 let model = output.model.clone();
@@ -131,9 +115,14 @@ impl DisplayConfig {
                 // not available.
                 let serial = output.serial.as_ref().unwrap_or(&connector).clone();
 
-            let names = (connector, make, model, serial);
+                let monitor = Monitor {
+                    names: (connector, make, model, serial),
+                    modes,
+                    properties,
+                };
+
+                let logical = output.logical.as_ref().unwrap();
 
-            if let Some(logical) = output.logical.as_ref() {
                 let transform = match logical.transform {
                     niri_ipc::Transform::Normal => 0,
                     niri_ipc::Transform::_90 => 1,
@@ -145,151 +134,35 @@ impl DisplayConfig {
                     niri_ipc::Transform::Flipped270 => 7,
                 };
 
-                logical_monitors.push(LogicalMonitor {
+                let logical_monitor = LogicalMonitor {
                     x: logical.x,
                     y: logical.y,
                     scale: logical.scale,
                     transform,
                     is_primary: false,
-                    monitors: vec![names.clone()],
+                    monitors: vec![monitor.names.clone()],
                     properties: HashMap::new(),
-                });
+                };
-            }
 
-            monitors.push(Monitor {
+                (monitor, logical_monitor)
-                names,
+            })
-                modes,
+            .collect();
-                properties,
-            });
-        }
 
         // Sort by connector.
-        monitors.sort_unstable_by(|a, b| a.names.0.cmp(&b.names.0));
+        monitors.sort_unstable_by(|a, b| a.0.names.0.cmp(&b.0.names.0));
-        logical_monitors.sort_unstable_by(|a, b| a.monitors[0].0.cmp(&b.monitors[0].0));
 
+        let (monitors, logical_monitors) = monitors.into_iter().unzip();
         let properties = HashMap::from([(String::from("layout-mode"), OwnedValue::from(1u32))]);
         Ok((0, monitors, logical_monitors, properties))
     }
 
-    async fn apply_monitors_config(
+    #[dbus_interface(signal)]
-        &self,
+    pub async fn monitors_changed(ctxt: &SignalContext<'_>) -> zbus::Result<()>;
-        _serial: u32,
-        method: u32,
-        logical_monitor_configs: Vec<LogicalMonitorConfiguration>,
-        _properties: HashMap<String, OwnedValue>,
-    ) -> fdo::Result<()> {
-        let current_conf = self.ipc_outputs.lock().unwrap();
-        let mut new_conf = HashMap::new();
-        for requested_config in logical_monitor_configs {
-            if requested_config.monitors.len() > 1 {
-                return Err(zbus::fdo::Error::Failed(
-                    "Mirroring is not yet supported".to_owned(),
-                ));
-            }
-            for (connector, mode, _props) in requested_config.monitors {
-                if !current_conf.values().any(|o| o.name == connector) {
-                    return Err(zbus::fdo::Error::Failed(format!(
-                        "Connector '{}' not found",
-                        connector
-                    )));
-                }
-                new_conf.insert(
-                    connector.clone(),
-                    Some(niri_config::Output {
-                        off: false,
-                        name: connector,
-                        scale: Some(niri_config::FloatOrInt(requested_config.scale)),
-                        transform: match requested_config.transform {
-                            0 => niri_ipc::Transform::Normal,
-                            1 => niri_ipc::Transform::_90,
-                            2 => niri_ipc::Transform::_180,
-                            3 => niri_ipc::Transform::_270,
-                            4 => niri_ipc::Transform::Flipped,
-                            5 => niri_ipc::Transform::Flipped90,
-                            6 => niri_ipc::Transform::Flipped180,
-                            7 => niri_ipc::Transform::Flipped270,
-                            x => {
-                                return Err(zbus::fdo::Error::Failed(format!(
-                                    "Unknown transform {}",
-                                    x
-                                )))
-                            }
-                        },
-                        position: Some(niri_config::Position {
-                            x: requested_config.x,
-                            y: requested_config.y,
-                        }),
-                        mode: Some(niri_ipc::ConfiguredMode::from_str(&mode).map_err(|e| {
-                            zbus::fdo::Error::Failed(format!(
-                                "Could not parse mode '{}': {}",
-                                mode, e
-                            ))
-                        })?),
-                        // FIXME: VRR
-                        ..Default::default()
-                    }),
-                );
-            }
-        }
-        if new_conf.is_empty() {
-            return Err(zbus::fdo::Error::Failed(
-                "At least one output must be enabled".to_owned(),
-            ));
-        }
-        for output in current_conf.values() {
-            if !new_conf.contains_key(&output.name) {
-                new_conf.insert(output.name.clone(), None);
-            }
-        }
-        if method == 0 {
-            // 0 means "verify", so don't actually apply here
-            return Ok(());
-        }
-        if let Err(err) = self.to_niri.send(new_conf) {
-            warn!("error sending message to niri: {err:?}");
-            return Err(fdo::Error::Failed("internal error".to_owned()));
-        }
-        Ok(())
-    }
-
-    #[zbus(signal)]
-    pub async fn monitors_changed(ctxt: &SignalEmitter<'_>) -> zbus::Result<()>;
-
-    #[zbus(property)]
-    fn power_save_mode(&self) -> i32 {
-        -1
-    }
-
-    #[zbus(property)]
-    fn set_power_save_mode(&self, _mode: i32) -> zbus::Result<()> {
-        Err(zbus::Error::Unsupported)
-    }
-
-    #[zbus(property)]
-    fn panel_orientation_managed(&self) -> bool {
-        false
-    }
-
-    #[zbus(property)]
-    fn apply_monitors_config_allowed(&self) -> bool {
-        true
-    }
-
-    #[zbus(property)]
-    fn night_light_supported(&self) -> bool {
-        false
-    }
 }
 
 impl DisplayConfig {
-    pub fn new(
+    pub fn new(ipc_outputs: Arc<Mutex<IpcOutputMap>>) -> Self {
-        to_niri: calloop::channel::Sender<HashMap<String, Option<niri_config::Output>>>,
+        Self { ipc_outputs }
-        ipc_outputs: Arc<Mutex<IpcOutputMap>>,
-    ) -> Self {
-        Self {
-            to_niri,
-            ipc_outputs,
-        }
     }
 }
 
@@ -339,16 +212,16 @@ fn format_diagonal(diagonal_inches: f64) -> String {
 
 #[cfg(test)]
 mod tests {
-    use insta::assert_snapshot;
+    use k9::snapshot;
 
     use super::*;
 
     #[test]
     fn test_format_diagonal() {
-        assert_snapshot!(format_diagonal(12.11), @"12.1″");
+        snapshot!(format_diagonal(12.11), "12.1″");
-        assert_snapshot!(format_diagonal(13.28), @"13.3″");
+        snapshot!(format_diagonal(13.28), "13.3″");
-        assert_snapshot!(format_diagonal(15.6), @"15.6″");
+        snapshot!(format_diagonal(15.6), "15.6″");
-        assert_snapshot!(format_diagonal(23.2), @"23″");
+        snapshot!(format_diagonal(23.2), "23″");
-        assert_snapshot!(format_diagonal(24.8), @"25″");
+        snapshot!(format_diagonal(24.8), "25″");
     }
 }

src/dbus/mutter_screen_cast.rs

@@ -5,9 +5,8 @@ use std::sync::{Arc, Mutex};
 
 use serde::Deserialize;
 use zbus::fdo::RequestNameFlags;
-use zbus::object_server::{InterfaceRef, SignalEmitter};
 use zbus::zvariant::{DeserializeDict, OwnedObjectPath, SerializeDict, Type, Value};
-use zbus::{fdo, interface, ObjectServer};
+use zbus::{dbus_interface, fdo, InterfaceRef, ObjectServer, SignalContext};
 
 use super::Start;
 use crate::backend::IpcOutputMap;
@@ -95,14 +94,14 @@ pub enum ScreenCastToNiri {
         session_id: usize,
         target: StreamTargetId,
         cursor_mode: CursorMode,
-        signal_ctx: SignalEmitter<'static>,
+        signal_ctx: SignalContext<'static>,
     },
     StopCast {
         session_id: usize,
     },
 }
 
-#[interface(name = "org.gnome.Mutter.ScreenCast")]
+#[dbus_interface(name = "org.gnome.Mutter.ScreenCast")]
 impl ScreenCast {
     async fn create_session(
         &self,
@@ -137,26 +136,26 @@ impl ScreenCast {
         Ok(path)
     }
 
-    #[zbus(property)]
+    #[dbus_interface(property)]
     async fn version(&self) -> i32 {
         4
     }
 }
 
-#[interface(name = "org.gnome.Mutter.ScreenCast.Session")]
+#[dbus_interface(name = "org.gnome.Mutter.ScreenCast.Session")]
 impl Session {
     async fn start(&self) {
         debug!("start");
 
         for (stream, iface) in &*self.streams.lock().unwrap() {
-            stream.start(self.id, iface.signal_emitter().clone());
+            stream.start(self.id, iface.signal_context().clone());
         }
     }
 
     pub async fn stop(
         &self,
         #[zbus(object_server)] server: &ObjectServer,
-        #[zbus(signal_context)] ctxt: SignalEmitter<'_>,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
     ) {
         debug!("stop");
 
@@ -176,7 +175,7 @@ impl Session {
         let streams = mem::take(&mut *self.streams.lock().unwrap());
         for (_, iface) in streams.iter() {
             server
-                .remove::<Stream, _>(iface.signal_emitter().path())
+                .remove::<Stream, _>(iface.signal_context().path())
                 .await
                 .unwrap();
         }
@@ -265,17 +264,17 @@ impl Session {
         Ok(path)
     }
 
-    #[zbus(signal)]
+    #[dbus_interface(signal)]
-    async fn closed(ctxt: &SignalEmitter<'_>) -> zbus::Result<()>;
+    async fn closed(ctxt: &SignalContext<'_>) -> zbus::Result<()>;
 }
 
-#[interface(name = "org.gnome.Mutter.ScreenCast.Stream")]
+#[dbus_interface(name = "org.gnome.Mutter.ScreenCast.Stream")]
 impl Stream {
-    #[zbus(signal)]
+    #[dbus_interface(signal)]
-    pub async fn pipe_wire_stream_added(ctxt: &SignalEmitter<'_>, node_id: u32)
+    pub async fn pipe_wire_stream_added(ctxt: &SignalContext<'_>, node_id: u32)
         -> zbus::Result<()>;
 
-    #[zbus(property)]
+    #[dbus_interface(property)]
     async fn parameters(&self) -> StreamParameters {
         match &self.target {
             StreamTarget::Output(output) => {
@@ -362,7 +361,7 @@ impl Stream {
         }
     }
 
-    fn start(&self, session_id: usize, ctxt: SignalEmitter<'static>) {
+    fn start(&self, session_id: usize, ctxt: SignalContext<'static>) {
         if self.was_started.load(Ordering::SeqCst) {
             return;
         }

src/dbus/mutter_service_channel.rs

@@ -1,51 +1,50 @@
+use std::os::fd::{FromRawFd, IntoRawFd};
 use std::os::unix::net::UnixStream;
+use std::sync::Arc;
 
-use zbus::{fdo, interface, zvariant};
+use smithay::reexports::wayland_server::DisplayHandle;
+use zbus::dbus_interface;
 
 use super::Start;
-use crate::niri::NewClient;
+use crate::niri::ClientState;
 
 pub struct ServiceChannel {
-    to_niri: calloop::channel::Sender<NewClient>,
+    display: DisplayHandle,
 }
 
-#[interface(name = "org.gnome.Mutter.ServiceChannel")]
+#[dbus_interface(name = "org.gnome.Mutter.ServiceChannel")]
 impl ServiceChannel {
     async fn open_wayland_service_connection(
         &mut self,
         service_client_type: u32,
-    ) -> fdo::Result<zvariant::OwnedFd> {
+    ) -> zbus::fdo::Result<zbus::zvariant::OwnedFd> {
         if service_client_type != 1 {
-            return Err(fdo::Error::InvalidArgs(
+            return Err(zbus::fdo::Error::InvalidArgs(
                 "Invalid service client type".to_owned(),
             ));
         }
 
         let (sock1, sock2) = UnixStream::pair().unwrap();
-        let client = NewClient {
+        let data = Arc::new(ClientState {
-            client: sock2,
+            compositor_state: Default::default(),
+            // Would be nice to thread config here but for now it's fine.
+            can_view_decoration_globals: false,
             restricted: false,
-            // FIXME: maybe you can get the PID from D-Bus somehow?
+        });
-            credentials_unknown: true,
+        self.display.insert_client(sock2, data).unwrap();
-        };
+        Ok(unsafe { zbus::zvariant::OwnedFd::from_raw_fd(sock1.into_raw_fd()) })
-        if let Err(err) = self.to_niri.send(client) {
-            warn!("error sending message to niri: {err:?}");
-            return Err(fdo::Error::Failed("internal error".to_owned()));
-        }
-
-        Ok(zvariant::OwnedFd::from(std::os::fd::OwnedFd::from(sock1)))
     }
 }
 
 impl ServiceChannel {
-    pub fn new(to_niri: calloop::channel::Sender<NewClient>) -> Self {
+    pub fn new(display: DisplayHandle) -> Self {
-        Self { to_niri }
+        Self { display }
     }
 }
 
 impl Start for ServiceChannel {
     fn start(self) -> anyhow::Result<zbus::blocking::Connection> {
-        let conn = zbus::blocking::connection::Builder::session()?
+        let conn = zbus::blocking::ConnectionBuilder::session()?
             .name("org.gnome.Mutter.ServiceChannel")?
             .serve_at("/org/gnome/Mutter/ServiceChannel", self)?
             .build()?;

src/handlers/compositor.rs

@@ -1,6 +1,5 @@
 use std::collections::hash_map::Entry;
 
-use niri_ipc::PositionChange;
 use smithay::backend::renderer::utils::{on_commit_buffer_handler, with_renderer_surface_state};
 use smithay::input::pointer::{CursorImageStatus, CursorImageSurfaceData};
 use smithay::reexports::calloop::Interest;
@@ -19,8 +18,6 @@ use smithay::wayland::shm::{ShmHandler, ShmState};
 use smithay::{delegate_compositor, delegate_shm};
 
 use super::xdg_shell::add_mapped_toplevel_pre_commit_hook;
-use crate::handlers::XDG_ACTIVATION_TOKEN_TIMEOUT;
-use crate::layout::{ActivateWindow, AddWindowTarget};
 use crate::niri::{ClientState, State};
 use crate::utils::send_scale_transform;
 use crate::utils::transaction::Transaction;
@@ -87,23 +84,16 @@ impl CompositorHandler for State {
 
                 if is_mapped {
                     // The toplevel got mapped.
-                    let Unmapped {
+                    let Unmapped { window, state } = entry.remove();
-                        window,
-                        state,
-                        activation_token_data,
-                    } = entry.remove();
 
                     window.on_commit();
 
                     let toplevel = window.toplevel().expect("no X11 support");
 
-                    let (rules, width, height, is_full_width, output, workspace_id) =
+                    let (rules, width, is_full_width, output, workspace_name) =
                         if let InitialConfigureState::Configured {
                             rules,
                             width,
-                            height,
-                            floating_width: _,
-                            floating_height: _,
                             is_full_width,
                             output,
                             workspace_name,
@@ -114,48 +104,15 @@ impl CompositorHandler for State {
                                 output.filter(|o| self.niri.layout.monitor_for_output(o).is_some());
 
                             // Check that the workspace still exists.
-                            let workspace_id = workspace_name
+                            let workspace_name = workspace_name
-                                .as_deref()
+                                .filter(|n| self.niri.layout.find_workspace_by_name(n).is_some());
-                                .and_then(|n| self.niri.layout.find_workspace_by_name(n))
-                                .map(|(_, ws)| ws.id());
 
-                            (rules, width, height, is_full_width, output, workspace_id)
+                            (rules, width, is_full_width, output, workspace_name)
                         } else {
                             error!("window map must happen after initial configure");
-                            (ResolvedWindowRules::empty(), None, None, false, None, None)
+                            (ResolvedWindowRules::empty(), None, false, None, None)
                         };
 
-                    // The GTK about dialog sets min/max size after the initial configure but
-                    // before mapping, so we need to compute open_floating at the last possible
-                    // moment, that is here.
-                    let is_floating = rules.compute_open_floating(toplevel);
-
-                    // Figure out if we should activate the window.
-                    let activate = rules.open_focused.map(|focus| {
-                        if focus {
-                            ActivateWindow::Yes
-                        } else {
-                            ActivateWindow::No
-                        }
-                    });
-                    let activate = activate.unwrap_or_else(|| {
-                        // Check the token timestamp again in case the window took a while between
-                        // requesting activation and mapping.
-                        let token = activation_token_data.filter(|token| {
-                            token.timestamp.elapsed() < XDG_ACTIVATION_TOKEN_TIMEOUT
-                        });
-                        if token.is_some() {
-                            ActivateWindow::Yes
-                        } else {
-                            let config = self.niri.config.borrow();
-                            if config.debug.strict_new_window_focus_policy {
-                                ActivateWindow::No
-                            } else {
-                                ActivateWindow::Smart
-                            }
-                        }
-                    });
-
                     let parent = toplevel
                         .parent()
                         .and_then(|parent| self.niri.layout.find_window_and_output(&parent))
@@ -166,9 +123,7 @@ impl CompositorHandler for State {
                         // None. If the configured output is set, that means it was set explicitly
                         // by a window rule or a fullscreen request.
                         .filter(|(_, parent_output)| {
-                            parent_output.is_none()
+                            output.is_none() || output.as_ref() == Some(*parent_output)
-                                || output.is_none()
-                                || output.as_ref() == *parent_output
                         })
                         .map(|(mapped, _)| mapped.window.clone());
 
@@ -178,34 +133,34 @@ impl CompositorHandler for State {
                     let mapped = Mapped::new(window, rules, hook);
                     let window = mapped.window.clone();
 
-                    let target = if let Some(p) = &parent {
+                    let output = if let Some(p) = parent {
-                        // Open dialogs next to their parent window.
+                        // Open dialogs immediately to the right of their parent window.
-                        AddWindowTarget::NextTo(p)
+                        self.niri
-                    } else if let Some(id) = workspace_id {
+                            .layout
-                        AddWindowTarget::Workspace(id)
+                            .add_window_right_of(&p, mapped, width, is_full_width)
-                    } else if let Some(output) = &output {
+                    } else if let Some(workspace_name) = &workspace_name {
-                        AddWindowTarget::Output(output)
+                        self.niri.layout.add_window_to_named_workspace(
-                    } else {
+                            workspace_name,
-                        AddWindowTarget::Auto
-                    };
-                    let output = self.niri.layout.add_window(
                             mapped,
-                        target,
                             width,
-                        height,
                             is_full_width,
-                        is_floating,
+                        )
-                        activate,
+                    } else if let Some(output) = &output {
-                    );
+                        self.niri
+                            .layout
+                            .add_window_on_output(output, mapped, width, is_full_width);
+                        Some(output)
+                    } else {
+                        self.niri.layout.add_window(mapped, width, is_full_width)
+                    };
 
                     if let Some(output) = output.cloned() {
                         self.niri.layout.start_open_animation_for_window(&window);
 
-                        let new_focus = self.niri.layout.focus().map(|m| &m.window);
+                        let new_active_window =
-                        if new_focus == Some(&window) {
+                            self.niri.layout.active_window().map(|(m, _)| &m.window);
-                            // We activated the newly opened window.
+                        if new_active_window == Some(&window) {
                             self.maybe_warp_cursor_to_focus();
-                            self.niri.layer_shell_on_demand_focus = None;
                         }
 
                         self.niri.queue_redraw(&output);
@@ -225,7 +180,7 @@ impl CompositorHandler for State {
             // This is a commit of a previously-mapped root or a non-toplevel root.
             if let Some((mapped, output)) = self.niri.layout.find_window_and_output(surface) {
                 let window = mapped.window.clone();
-                let output = output.cloned();
+                let output = output.clone();
 
                 #[cfg(feature = "xdp-gnome-screencast")]
                 let id = mapped.id();
@@ -255,7 +210,7 @@ impl CompositorHandler for State {
                     // The toplevel got unmapped.
                     //
                     // Test client: wleird-unmap.
-                    let active_window = self.niri.layout.focus().map(|m| &m.window);
+                    let active_window = self.niri.layout.active_window().map(|(m, _)| &m.window);
                     let was_active = active_window == Some(&window);
 
                     #[cfg(feature = "xdp-gnome-screencast")]
@@ -282,27 +237,18 @@ impl CompositorHandler for State {
                     let unmapped = Unmapped::new(window);
                     self.niri.unmapped_windows.insert(surface.clone(), unmapped);
 
-                    if let Some(output) = output {
                     self.niri.queue_redraw(&output);
-                    }
                     return;
                 }
 
-                let (serial, buffer_delta) = with_states(surface, |states| {
+                let serial = with_states(surface, |states| {
-                    let buffer_delta = states
-                        .cached_state
-                        .get::<SurfaceAttributes>()
-                        .current()
-                        .buffer_delta
-                        .take();
-
                     let role = states
                         .data_map
                         .get::<XdgToplevelSurfaceData>()
                         .unwrap()
                         .lock()
                         .unwrap();
-                    (role.configure_serial, buffer_delta)
+                    role.configure_serial
                 });
                 if serial.is_none() {
                     error!("commit on a mapped surface without a configured serial");
@@ -311,25 +257,10 @@ impl CompositorHandler for State {
                 // The toplevel remains mapped.
                 self.niri.layout.update_window(&window, serial);
 
-                // Move the toplevel according to the attach offset.
-                if let Some(delta) = buffer_delta {
-                    if delta.x != 0 || delta.y != 0 {
-                        let (x, y) = delta.to_f64().into();
-                        self.niri.layout.move_floating_window(
-                            Some(&window),
-                            PositionChange::AdjustFixed(x),
-                            PositionChange::AdjustFixed(y),
-                            false,
-                        );
-                    }
-                }
-
                 // Popup placement depends on window size which might have changed.
-                self.update_reactive_popups(&window);
+                self.update_reactive_popups(&window, &output);
 
-                if let Some(output) = output {
                 self.niri.queue_redraw(&output);
-                }
                 return;
             }
 
@@ -340,12 +271,10 @@ impl CompositorHandler for State {
         let root_window_output = self.niri.layout.find_window_and_output(&root_surface);
         if let Some((mapped, output)) = root_window_output {
             let window = mapped.window.clone();
-            let output = output.cloned();
+            let output = output.clone();
             window.on_commit();
             self.niri.layout.update_window(&window, None);
-            if let Some(output) = output {
             self.niri.queue_redraw(&output);
-            }
             return;
         }
 

src/handlers/layer_shell.rs

@@ -11,7 +11,6 @@ use smithay::wayland::shell::wlr_layer::{
 };
 use smithay::wayland::shell::xdg::PopupSurface;
 
-use crate::layer::{MappedLayer, ResolvedLayerRules};
 use crate::niri::State;
 use crate::utils::send_scale_transform;
 
@@ -61,7 +60,6 @@ impl WlrLayerShellHandler for State {
                 layer.map(|layer| (o.clone(), map, layer))
             }) {
             map.unmap_layer(&layer);
-            self.niri.mapped_layer_surfaces.remove(&layer);
             Some(output)
         } else {
             None
@@ -130,22 +128,6 @@ impl State {
                 if is_mapped {
                     let was_unmapped = self.niri.unmapped_layer_surfaces.remove(surface);
 
-                    // Resolve rules for newly mapped layer surfaces.
-                    if was_unmapped {
-                        let config = self.niri.config.borrow();
-                        let rules = &config.layer_rules;
-                        let rules =
-                            ResolvedLayerRules::compute(rules, layer, self.niri.is_at_startup);
-                        let mapped = MappedLayer::new(layer.clone(), rules, &config);
-                        let prev = self
-                            .niri
-                            .mapped_layer_surfaces
-                            .insert(layer.clone(), mapped);
-                        if prev.is_some() {
-                            error!("MappedLayer was present for an unmapped surface");
-                        }
-                    }
-
                     // Give focus to newly mapped on-demand surfaces. Some launchers like
                     // lxqt-runner rely on this behavior. While this behavior doesn't make much
                     // sense for other clients like panels, the consensus seems to be that it's not
@@ -169,7 +151,6 @@ impl State {
                         self.niri.layer_shell_on_demand_focus = Some(layer.clone());
                     }
                 } else {
-                    self.niri.mapped_layer_surfaces.remove(layer);
                     self.niri.unmapped_layer_surfaces.insert(surface.clone());
                 }
             } else {

src/handlers/mod.rs

@@ -11,7 +11,7 @@ use std::time::Duration;
 
 use smithay::backend::allocator::dmabuf::Dmabuf;
 use smithay::backend::drm::DrmNode;
-use smithay::backend::input::{InputEvent, TabletToolDescriptor};
+use smithay::backend::input::TabletToolDescriptor;
 use smithay::desktop::{PopupKind, PopupManager};
 use smithay::input::pointer::{
     CursorIcon, CursorImageStatus, CursorImageSurfaceData, PointerHandle,
@@ -35,9 +35,6 @@ use smithay::wayland::fractional_scale::FractionalScaleHandler;
 use smithay::wayland::idle_inhibit::IdleInhibitHandler;
 use smithay::wayland::idle_notify::{IdleNotifierHandler, IdleNotifierState};
 use smithay::wayland::input_method::{InputMethodHandler, PopupSurface};
-use smithay::wayland::keyboard_shortcuts_inhibit::{
-    KeyboardShortcutsInhibitHandler, KeyboardShortcutsInhibitState, KeyboardShortcutsInhibitor,
-};
 use smithay::wayland::output::OutputHandler;
 use smithay::wayland::pointer_constraints::{with_pointer_constraint, PointerConstraintsHandler};
 use smithay::wayland::security_context::{
@@ -47,15 +44,10 @@ use smithay::wayland::selection::data_device::{
     set_data_device_focus, ClientDndGrabHandler, DataDeviceHandler, DataDeviceState,
     ServerDndGrabHandler,
 };
-use smithay::wayland::selection::ext_data_control::{
-    DataControlHandler as ExtDataControlHandler, DataControlState as ExtDataControlState,
-};
 use smithay::wayland::selection::primary_selection::{
     set_primary_focus, PrimarySelectionHandler, PrimarySelectionState,
 };
-use smithay::wayland::selection::wlr_data_control::{
+use smithay::wayland::selection::wlr_data_control::{DataControlHandler, DataControlState};
-    DataControlHandler as WlrDataControlHandler, DataControlState as WlrDataControlState,
-};
 use smithay::wayland::selection::{SelectionHandler, SelectionTarget};
 use smithay::wayland::session_lock::{
     LockSurface, SessionLockHandler, SessionLockManagerState, SessionLocker,
@@ -66,17 +58,16 @@ use smithay::wayland::xdg_activation::{
 };
 use smithay::{
     delegate_cursor_shape, delegate_data_control, delegate_data_device, delegate_dmabuf,
-    delegate_drm_lease, delegate_ext_data_control, delegate_fractional_scale,
+    delegate_drm_lease, delegate_fractional_scale, delegate_idle_inhibit, delegate_idle_notify,
-    delegate_idle_inhibit, delegate_idle_notify, delegate_input_method_manager,
+    delegate_input_method_manager, delegate_output, delegate_pointer_constraints,
-    delegate_keyboard_shortcuts_inhibit, delegate_output, delegate_pointer_constraints,
     delegate_pointer_gestures, delegate_presentation, delegate_primary_selection,
     delegate_relative_pointer, delegate_seat, delegate_security_context, delegate_session_lock,
-    delegate_single_pixel_buffer, delegate_tablet_manager, delegate_text_input_manager,
+    delegate_tablet_manager, delegate_text_input_manager, delegate_viewporter,
-    delegate_viewporter, delegate_virtual_keyboard_manager, delegate_xdg_activation,
+    delegate_virtual_keyboard_manager, delegate_xdg_activation,
 };
 
 pub use crate::handlers::xdg_shell::KdeDecorationsModeState;
-use crate::niri::{DndIcon, NewClient, State};
+use crate::niri::{ClientState, DndIcon, State};
 use crate::protocols::foreign_toplevel::{
     self, ForeignToplevelHandler, ForeignToplevelManagerState,
 };
@@ -84,15 +75,10 @@ use crate::protocols::gamma_control::{GammaControlHandler, GammaControlManagerSt
 use crate::protocols::mutter_x11_interop::MutterX11InteropHandler;
 use crate::protocols::output_management::{OutputManagementHandler, OutputManagementManagerState};
 use crate::protocols::screencopy::{Screencopy, ScreencopyHandler, ScreencopyManagerState};
-use crate::protocols::virtual_pointer::{
-    VirtualPointerAxisEvent, VirtualPointerButtonEvent, VirtualPointerHandler,
-    VirtualPointerInputBackend, VirtualPointerManagerState, VirtualPointerMotionAbsoluteEvent,
-    VirtualPointerMotionEvent,
-};
 use crate::utils::{output_size, send_scale_transform, with_toplevel_role};
 use crate::{
     delegate_foreign_toplevel, delegate_gamma_control, delegate_mutter_x11_interop,
-    delegate_output_management, delegate_screencopy, delegate_virtual_pointer,
+    delegate_output_management, delegate_screencopy,
 };
 
 pub const XDG_ACTIVATION_TOKEN_TIMEOUT: Duration = Duration::from_secs(10);
@@ -169,7 +155,7 @@ impl PointerConstraintsHandler for State {
         location: Point<f64, Logical>,
     ) {
         let is_constraint_active = with_pointer_constraint(surface, pointer, |constraint| {
-            constraint.is_some_and(|c| c.is_active())
+            constraint.map_or(false, |c| c.is_active())
         });
 
         if !is_constraint_active {
@@ -257,28 +243,7 @@ impl InputMethodHandler for State {
     }
 }
 
-impl KeyboardShortcutsInhibitHandler for State {
-    fn keyboard_shortcuts_inhibit_state(&mut self) -> &mut KeyboardShortcutsInhibitState {
-        &mut self.niri.keyboard_shortcuts_inhibit_state
-    }
-
-    fn new_inhibitor(&mut self, inhibitor: KeyboardShortcutsInhibitor) {
-        // FIXME: show a confirmation dialog with a "remember for this application" kind of toggle.
-        inhibitor.activate();
-        self.niri
-            .keyboard_shortcuts_inhibiting_surfaces
-            .insert(inhibitor.wl_surface().clone(), inhibitor);
-    }
-
-    fn inhibitor_destroyed(&mut self, inhibitor: KeyboardShortcutsInhibitor) {
-        self.niri
-            .keyboard_shortcuts_inhibiting_surfaces
-            .remove(&inhibitor.wl_surface().clone());
-    }
-}
-
 delegate_input_method_manager!(State);
-delegate_keyboard_shortcuts_inhibit!(State);
 delegate_virtual_keyboard_manager!(State);
 
 impl SelectionHandler for State {
@@ -341,42 +306,7 @@ impl ClientDndGrabHandler for State {
         self.niri.queue_redraw_all();
     }
 
-    fn dropped(&mut self, target: Option<WlSurface>, validated: bool, _seat: Seat<Self>) {
+    fn dropped(&mut self, _seat: Seat<Self>) {
-        trace!("client dropped, target: {target:?}, validated: {validated}");
-
-        // End DnD before activating a specific window below so that it takes precedence.
-        self.niri.layout.dnd_end();
-
-        // Activate the target output, since that's how Firefox drag-tab-into-new-window works for
-        // example. On successful drop, additionally activate the target window.
-        let mut activate_output = true;
-        if let Some(target) = validated.then_some(target).flatten() {
-            let root = self.niri.find_root_shell_surface(&target);
-            if let Some((mapped, _)) = self.niri.layout.find_window_and_output(&root) {
-                let window = mapped.window.clone();
-                self.niri.layout.activate_window(&window);
-                self.niri.layer_shell_on_demand_focus = None;
-                activate_output = false;
-            }
-        }
-
-        if activate_output {
-            // Find the output from cursor coordinates.
-            //
-            // FIXME: uhhh, we can't actually properly tell if the DnD comes from pointer or touch,
-            // and if it comes from touch, then what the coordinates are. Need to pass more
-            // parameters from Smithay I guess.
-            //
-            // Assume that hidden pointer means touch DnD.
-            if !self.niri.pointer_hidden {
-                // We can't even get the current pointer location because it's locked (we're deep
-                // in the grab call stack here). So use the last known one.
-                if let Some(output) = &self.niri.pointer_contents.output {
-                    self.niri.layout.activate_output(output);
-                }
-            }
-        }
-
         self.niri.dnd_icon = None;
         // FIXME: more granular
         self.niri.queue_redraw_all();
@@ -394,22 +324,14 @@ impl PrimarySelectionHandler for State {
 }
 delegate_primary_selection!(State);
 
-impl WlrDataControlHandler for State {
+impl DataControlHandler for State {
-    fn data_control_state(&self) -> &WlrDataControlState {
+    fn data_control_state(&self) -> &DataControlState {
-        &self.niri.wlr_data_control_state
+        &self.niri.data_control_state
     }
 }
 
 delegate_data_control!(State);
 
-impl ExtDataControlHandler for State {
-    fn data_control_state(&self) -> &ExtDataControlState {
-        &self.niri.ext_data_control_state
-    }
-}
-
-delegate_ext_data_control!(State);
-
 impl OutputHandler for State {
     fn output_bound(&mut self, output: Output, wl_output: WlOutput) {
         foreign_toplevel::on_output_bound(self, &output, &wl_output);
@@ -450,8 +372,6 @@ impl SessionLockHandler for State {
 
     fn unlock(&mut self) {
         self.niri.unlock();
-        self.niri.activate_monitors(&mut self.backend);
-        self.niri.notify_activity();
     }
 
     fn new_surface(&mut self, surface: LockSurface, output: WlOutput) {
@@ -485,12 +405,18 @@ impl SecurityContextHandler for State {
         self.niri
             .event_loop
             .insert_source(source, move |client, _, state| {
-                trace!("inserting a new restricted client, context={context:?}");
+                let config = state.niri.config.borrow();
-                state.niri.insert_client(NewClient {
+                let data = Arc::new(ClientState {
-                    client,
+                    compositor_state: Default::default(),
+                    can_view_decoration_globals: config.prefer_no_csd,
                     restricted: true,
-                    credentials_unknown: false,
                 });
+
+                if let Err(err) = state.niri.display_handle.insert_client(client, data) {
+                    warn!("error inserting client: {err}");
+                } else {
+                    trace!("inserted a new restricted client, context={context:?}");
+                }
             })
             .unwrap();
     }
@@ -550,7 +476,7 @@ impl ForeignToplevelHandler for State {
             let window = mapped.window.clone();
 
             if let Some(requested_output) = wl_output.as_ref().and_then(Output::from_resource) {
-                if Some(&requested_output) != current_output {
+                if &requested_output != current_output {
                     self.niri
                         .layout
                         .move_to_output(Some(&window), &requested_output, None);
@@ -598,31 +524,6 @@ impl ScreencopyHandler for State {
 }
 delegate_screencopy!(State);
 
-impl VirtualPointerHandler for State {
-    fn virtual_pointer_manager_state(&mut self) -> &mut VirtualPointerManagerState {
-        &mut self.niri.virtual_pointer_state
-    }
-
-    fn on_virtual_pointer_motion(&mut self, event: VirtualPointerMotionEvent) {
-        self.process_input_event(InputEvent::<VirtualPointerInputBackend>::PointerMotion { event });
-    }
-
-    fn on_virtual_pointer_motion_absolute(&mut self, event: VirtualPointerMotionAbsoluteEvent) {
-        self.process_input_event(
-            InputEvent::<VirtualPointerInputBackend>::PointerMotionAbsolute { event },
-        );
-    }
-
-    fn on_virtual_pointer_button(&mut self, event: VirtualPointerButtonEvent) {
-        self.process_input_event(InputEvent::<VirtualPointerInputBackend>::PointerButton { event });
-    }
-
-    fn on_virtual_pointer_axis(&mut self, event: VirtualPointerAxisEvent) {
-        self.process_input_event(InputEvent::<VirtualPointerInputBackend>::PointerAxis { event });
-    }
-}
-delegate_virtual_pointer!(State);
-
 impl DrmLeaseHandler for State {
     fn drm_lease_state(&mut self, node: DrmNode) -> &mut DrmLeaseState {
         self.backend
@@ -736,13 +637,11 @@ impl XdgActivationHandler for State {
                 self.niri.layout.activate_window(&window);
                 self.niri.layer_shell_on_demand_focus = None;
                 self.niri.queue_redraw_all();
-            } else if let Some(unmapped) = self.niri.unmapped_windows.get_mut(&surface) {
-                unmapped.activation_token_data = Some(token_data);
-            }
-        }
 
                 self.niri.activation_state.remove_token(&token);
             }
+        }
+    }
 }
 delegate_xdg_activation!(State);
 
@@ -763,5 +662,3 @@ delegate_output_management!(State);
 
 impl MutterX11InteropHandler for State {}
 delegate_mutter_x11_interop!(State);
-
-delegate_single_pixel_buffer!(State);

src/handlers/xdg_shell.rs

@@ -1,7 +1,6 @@
 use std::cell::Cell;
 
 use calloop::Interest;
-use niri_config::PresetSize;
 use smithay::desktop::{
     find_popup_root_surface, get_popup_toplevel_coords, layer_map_for_output, utils, LayerSurface,
     PopupKeyboardGrab, PopupKind, PopupManager, PopupPointerGrab, PopupUngrabStrategy, Window,
@@ -43,6 +42,7 @@ use crate::input::resize_grab::ResizeGrab;
 use crate::input::touch_move_grab::TouchMoveGrab;
 use crate::input::touch_resize_grab::TouchResizeGrab;
 use crate::input::{PointerOrTouchStartData, DOUBLE_CLICK_TIME};
+use crate::layout::workspace::ColumnWidth;
 use crate::niri::{PopupGrabState, State};
 use crate::utils::transaction::Transaction;
 use crate::utils::{get_monotonic_time, output_matches_name, send_scale_transform, ResizeEdge};
@@ -123,10 +123,6 @@ impl XdgShellHandler for State {
             return;
         };
 
-        let Some(output) = output else {
-            return;
-        };
-
         let window = mapped.window.clone();
         let output = output.clone();
 
@@ -213,16 +209,8 @@ impl XdgShellHandler for State {
         // See if we got a double resize-click gesture.
         let time = get_monotonic_time();
         let last_cell = mapped.last_interactive_resize_start();
-        let mut last = last_cell.get();
+        let last = last_cell.get();
         last_cell.set(Some((time, edges)));
-
-        // Floating windows don't have either of the double-resize-click gestures, so just allow it
-        // to resize.
-        if mapped.is_floating() {
-            last = None;
-            last_cell.set(None);
-        }
-
         if let Some((last_time, last_edges)) = last {
             if time.saturating_sub(last_time) <= DOUBLE_CLICK_TIME {
                 // Allow quick resize after a triple click.
@@ -293,7 +281,6 @@ impl XdgShellHandler for State {
 
         let popup = PopupKind::Xdg(surface);
         let Ok(root) = find_popup_root_surface(&popup) else {
-            trace!("ignoring popup grab because no root surface");
             return;
         };
 
@@ -302,30 +289,30 @@ impl XdgShellHandler for State {
         // keyboard focus being at the wrong place.
         if self.niri.is_locked() {
             if Some(&root) != self.niri.lock_surface_focus().as_ref() {
-                trace!("ignoring popup grab because the session is locked");
                 let _ = PopupManager::dismiss_popup(&root, &popup);
                 return;
             }
         } else if self.niri.screenshot_ui.is_open() {
-            trace!("ignoring popup grab because the screenshot UI is open");
             let _ = PopupManager::dismiss_popup(&root, &popup);
             return;
         } else if let Some(output) = self.niri.layout.active_output() {
             let layers = layer_map_for_output(output);
 
-            if layers
+            if let Some(layer_surface) =
-                .layer_for_surface(&root, WindowSurfaceType::TOPLEVEL)
+                layers.layer_for_surface(&root, WindowSurfaceType::TOPLEVEL)
-                .is_none()
             {
-                // This is a grab for a regular window; check that there's no layer surface with a
+                if !matches!(layer_surface.layer(), Layer::Overlay | Layer::Top) {
-                // higher input priority.
+                    let _ = PopupManager::dismiss_popup(&root, &popup);
+                    return;
+                }
 
+                // FIXME: popup grabs for on-demand bottom and background layers.
+            } else {
                 if layers.layers_on(Layer::Overlay).any(|l| {
                     l.cached_state().keyboard_interactivity
                         == wlr_layer::KeyboardInteractivity::Exclusive
                         || Some(l) == self.niri.layer_shell_on_demand_focus.as_ref()
                 }) {
-                    trace!("ignoring toplevel popup grab because the overlay layer has focus");
                     let _ = PopupManager::dismiss_popup(&root, &popup);
                     return;
                 }
@@ -338,51 +325,33 @@ impl XdgShellHandler for State {
                             || Some(l) == self.niri.layer_shell_on_demand_focus.as_ref()
                     })
                 {
-                    trace!("ignoring toplevel popup grab because the top layer has focus");
                     let _ = PopupManager::dismiss_popup(&root, &popup);
                     return;
                 }
 
                 let layout_focus = self.niri.layout.focus();
                 if Some(&root) != layout_focus.map(|win| win.toplevel().wl_surface()) {
-                    trace!("ignoring toplevel popup grab because another window has focus");
                     let _ = PopupManager::dismiss_popup(&root, &popup);
                     return;
                 }
             }
         } else {
-            trace!("ignoring popup grab because no output is active");
             let _ = PopupManager::dismiss_popup(&root, &popup);
             return;
         }
 
         let seat = &self.niri.seat;
-        let mut grab = match self
+        let Ok(mut grab) = self
             .niri
             .popups
             .grab_popup(root.clone(), popup, seat, serial)
-        {
+        else {
-            Ok(grab) => grab,
-            Err(err) => {
-                trace!("ignoring popup grab: {err:?}");
             return;
-            }
         };
 
         let keyboard = seat.get_keyboard().unwrap();
         let pointer = seat.get_pointer().unwrap();
 
-        let can_receive_keyboard_focus = self
-            .niri
-            .layout
-            .active_output()
-            .and_then(|output| {
-                layer_map_for_output(output)
-                    .layer_for_surface(&root, WindowSurfaceType::TOPLEVEL)
-                    .map(|layer_surface| layer_surface.can_receive_keyboard_focus())
-            })
-            .unwrap_or(true);
-
         let keyboard_grab_mismatches = keyboard.is_grabbed()
             && !(keyboard.has_grab(serial)
                 || grab
@@ -391,22 +360,16 @@ impl XdgShellHandler for State {
         let pointer_grab_mismatches = pointer.is_grabbed()
             && !(pointer.has_grab(serial)
                 || grab.previous_serial().map_or(true, |s| pointer.has_grab(s)));
-        if (can_receive_keyboard_focus && keyboard_grab_mismatches) || pointer_grab_mismatches {
+        if keyboard_grab_mismatches || pointer_grab_mismatches {
-            trace!("ignoring popup grab because of current grab mismatch");
             grab.ungrab(PopupUngrabStrategy::All);
             return;
         }
 
         trace!("new grab for root {:?}", root);
-        if can_receive_keyboard_focus {
+        keyboard.set_focus(self, grab.current_grab(), serial);
         keyboard.set_grab(self, PopupKeyboardGrab::new(&grab), serial);
-        }
         pointer.set_grab(self, PopupPointerGrab::new(&grab), serial, Focus::Keep);
-        self.niri.popup_grab = Some(PopupGrabState {
+        self.niri.popup_grab = Some(PopupGrabState { root, grab });
-            root,
-            grab,
-            has_keyboard_grab: can_receive_keyboard_focus,
-        });
     }
 
     fn maximize_request(&mut self, surface: ToplevelSurface) {
@@ -433,16 +396,12 @@ impl XdgShellHandler for State {
         if let Some((mapped, current_output)) = self
             .niri
             .layout
-            .find_window_and_output_mut(toplevel.wl_surface())
+            .find_window_and_output(toplevel.wl_surface())
         {
-            // A configure is required in response to this event regardless if there are pending
-            // changes.
-            mapped.set_needs_configure();
-
             let window = mapped.window.clone();
 
             if let Some(requested_output) = requested_output {
-                if Some(&requested_output) != current_output {
+                if &requested_output != current_output {
                     self.niri
                         .layout
                         .move_to_output(Some(&window), &requested_output, None);
@@ -450,6 +409,10 @@ impl XdgShellHandler for State {
             }
 
             self.niri.layout.set_fullscreen(&window, true);
+
+            // A configure is required in response to this event regardless if there are pending
+            // changes.
+            toplevel.send_configure();
         } else if let Some(unmapped) = self.niri.unmapped_windows.get_mut(toplevel.wl_surface()) {
             match &mut unmapped.state {
                 InitialConfigureState::NotConfigured { wants_fullscreen } => {
@@ -471,7 +434,7 @@ impl XdgShellHandler for State {
                             toplevel
                                 .parent()
                                 .and_then(|parent| self.niri.layout.find_window_and_output(&parent))
-                                .and_then(|(_win, output)| output)
+                                .map(|(_win, output)| output)
                                 .and_then(|o| self.niri.layout.monitor_for_output(o))
                                 .map(|mon| (mon, true))
                         })
@@ -496,7 +459,7 @@ impl XdgShellHandler for State {
                         toplevel.with_pending_state(|state| {
                             state.states.set(xdg_toplevel::State::Fullscreen);
                         });
-                        ws.configure_new_window(&unmapped.window, None, None, false, rules);
+                        ws.configure_new_window(&unmapped.window, None, rules);
                     }
 
                     // We already sent the initial configure, so we need to reconfigure.
@@ -513,14 +476,14 @@ impl XdgShellHandler for State {
         if let Some((mapped, _)) = self
             .niri
             .layout
-            .find_window_and_output_mut(toplevel.wl_surface())
+            .find_window_and_output(toplevel.wl_surface())
         {
-            // A configure is required in response to this event regardless if there are pending
-            // changes.
-            mapped.set_needs_configure();
-
             let window = mapped.window.clone();
             self.niri.layout.set_fullscreen(&window, false);
+
+            // A configure is required in response to this event regardless if there are pending
+            // changes.
+            toplevel.send_configure();
         } else if let Some(unmapped) = self.niri.unmapped_windows.get_mut(toplevel.wl_surface()) {
             match &mut unmapped.state {
                 InitialConfigureState::NotConfigured { wants_fullscreen } => {
@@ -531,9 +494,6 @@ impl XdgShellHandler for State {
                 InitialConfigureState::Configured {
                     rules,
                     width,
-                    height,
-                    floating_width,
-                    floating_height,
                     is_full_width,
                     output,
                     workspace_name,
@@ -557,7 +517,7 @@ impl XdgShellHandler for State {
                                     .and_then(|parent| {
                                         self.niri.layout.find_window_and_output(&parent)
                                     })
-                                    .and_then(|(_win, output)| output)
+                                    .map(|(_win, output)| output)
                                     .and_then(|o| self.niri.layout.monitor_for_output(o))
                                     .map(|mon| (mon, true))
                             })
@@ -588,26 +548,12 @@ impl XdgShellHandler for State {
                             state.states.unset(xdg_toplevel::State::Fullscreen);
                         });
 
-                        let is_floating = rules.compute_open_floating(&toplevel);
+                        let configure_width = if *is_full_width {
-                        let configure_width = if is_floating {
+                            Some(ColumnWidth::Proportion(1.))
-                            *floating_width
-                        } else if *is_full_width {
-                            Some(PresetSize::Proportion(1.))
                         } else {
                             *width
                         };
-                        let configure_height = if is_floating {
+                        ws.configure_new_window(&unmapped.window, configure_width, rules);
-                            *floating_height
-                        } else {
-                            *height
-                        };
-                        ws.configure_new_window(
-                            &unmapped.window,
-                            configure_width,
-                            configure_height,
-                            is_floating,
-                            rules,
-                        );
                     }
 
                     // We already sent the initial configure, so we need to reconfigure.
@@ -643,7 +589,7 @@ impl XdgShellHandler for State {
             return;
         };
         let window = mapped.window.clone();
-        let output = output.cloned();
+        let output = output.clone();
 
         #[cfg(feature = "xdp-gnome-screencast")]
         self.niri
@@ -663,7 +609,7 @@ impl XdgShellHandler for State {
                 .start_close_animation_for_window(renderer, &window, blocker);
         });
 
-        let active_window = self.niri.layout.focus().map(|m| &m.window);
+        let active_window = self.niri.layout.active_window().map(|(m, _)| &m.window);
         let was_active = active_window == Some(&window);
 
         self.niri.layout.remove_window(&window, transaction.clone());
@@ -679,10 +625,8 @@ impl XdgShellHandler for State {
             self.maybe_warp_cursor_to_focus();
         }
 
-        if let Some(output) = output {
         self.niri.queue_redraw(&output);
     }
-    }
 
     fn popup_destroyed(&mut self, surface: PopupSurface) {
         if let Some(output) = self.output_for_popup(&PopupKind::Xdg(surface)) {
@@ -697,22 +641,6 @@ impl XdgShellHandler for State {
     fn title_changed(&mut self, toplevel: ToplevelSurface) {
         self.update_window_rules(&toplevel);
     }
-
-    fn parent_changed(&mut self, toplevel: ToplevelSurface) {
-        let Some(parent) = toplevel.parent() else {
-            return;
-        };
-
-        if let Some((mapped, output)) = self.niri.layout.find_window_and_output_mut(&parent) {
-            let output = output.cloned();
-            let window = mapped.window.clone();
-            if self.niri.layout.descendants_added(&window) {
-                if let Some(output) = output {
-                    self.niri.queue_redraw(&output);
-                }
-            }
-        }
-    }
 }
 
 delegate_xdg_shell!(State);
@@ -741,15 +669,9 @@ impl XdgDecorationHandler for State {
         // A configure is required in response to this event. However, if an initial configure
         // wasn't sent, then we will send this as part of the initial configure later.
         if toplevel.is_initial_configure_sent() {
-            // If this is a mapped window, flag it as needs configure to avoid duplicate configures.
-            let surface = toplevel.wl_surface();
-            if let Some((mapped, _)) = self.niri.layout.find_window_and_output_mut(surface) {
-                mapped.set_needs_configure();
-            } else {
             toplevel.send_configure();
         }
     }
-    }
 
     fn unset_mode(&mut self, toplevel: ToplevelSurface) {
         // If we want CSD, we hide this global altogether.
@@ -760,15 +682,9 @@ impl XdgDecorationHandler for State {
         // A configure is required in response to this event. However, if an initial configure
         // wasn't sent, then we will send this as part of the initial configure later.
         if toplevel.is_initial_configure_sent() {
-            // If this is a mapped window, flag it as needs configure to avoid duplicate configures.
-            let surface = toplevel.wl_surface();
-            if let Some((mapped, _)) = self.niri.layout.find_window_and_output_mut(surface) {
-                mapped.set_needs_configure();
-            } else {
             toplevel.send_configure();
         }
     }
-    }
 }
 delegate_xdg_decoration!(State);
 
@@ -836,7 +752,7 @@ impl State {
             self.niri.is_at_startup,
         );
 
-        let Unmapped { window, state, .. } = unmapped;
+        let Unmapped { window, state } = unmapped;
 
         let InitialConfigureState::NotConfigured { wants_fullscreen } = state else {
             error!("window must not be already configured in send_initial_configure()");
@@ -877,7 +793,7 @@ impl State {
             toplevel
                 .parent()
                 .and_then(|parent| self.niri.layout.find_window_and_output(&parent))
-                .and_then(|(_win, output)| output)
+                .map(|(_win, output)| output)
                 .and_then(|o| self.niri.layout.monitor_for_output(o))
                 .map(|mon| (mon, true))
         });
@@ -898,11 +814,7 @@ impl State {
         let mon = mon.map(|(mon, _)| mon);
 
         let mut width = None;
-        let mut floating_width = None;
-        let mut height = None;
-        let mut floating_height = None;
         let is_full_width = rules.open_maximized.unwrap_or(false);
-        let is_floating = rules.compute_open_floating(toplevel);
 
         // Tell the surface the preferred size and bounds for its likely output.
         let ws = rules
@@ -924,26 +836,14 @@ impl State {
                 });
             }
 
-            width = ws.resolve_default_width(rules.default_width, false);
+            width = ws.resolve_default_width(rules.default_width);
-            floating_width = ws.resolve_default_width(rules.default_width, true);
-            height = ws.resolve_default_height(rules.default_height, false);
-            floating_height = ws.resolve_default_height(rules.default_height, true);
 
-            let configure_width = if is_floating {
+            let configure_width = if is_full_width {
-                floating_width
+                Some(ColumnWidth::Proportion(1.))
-            } else if is_full_width {
-                Some(PresetSize::Proportion(1.))
             } else {
                 width
             };
-            let configure_height = if is_floating { floating_height } else { height };
+            ws.configure_new_window(window, configure_width, &rules);
-            ws.configure_new_window(
-                window,
-                configure_width,
-                configure_height,
-                is_floating,
-                &rules,
-            );
         }
 
         // If the user prefers no CSD, it's a reasonable assumption that they would prefer to get
@@ -961,9 +861,6 @@ impl State {
         *state = InitialConfigureState::Configured {
             rules,
             width,
-            height,
-            floating_width,
-            floating_height,
             is_full_width,
             output,
             workspace_name: ws.and_then(|w| w.name().cloned()),
@@ -1031,8 +928,8 @@ impl State {
         };
 
         // Figure out if the root is a window or a layer surface.
-        if let Some((mapped, _)) = self.niri.layout.find_window_and_output(&root) {
+        if let Some((mapped, output)) = self.niri.layout.find_window_and_output(&root) {
-            self.unconstrain_window_popup(popup, &mapped.window);
+            self.unconstrain_window_popup(popup, &mapped.window, output);
         } else if let Some((layer_surface, output)) = self.niri.layout.outputs().find_map(|o| {
             let map = layer_map_for_output(o);
             let layer_surface = map.layer_for_surface(&root, WindowSurfaceType::TOPLEVEL)?;
@@ -1042,10 +939,19 @@ impl State {
         }
     }
 
-    fn unconstrain_window_popup(&self, popup: &PopupKind, window: &Window) {
+    fn unconstrain_window_popup(&self, popup: &PopupKind, window: &Window, output: &Output) {
+        let window_geo = window.geometry();
+        let output_geo = self.niri.global_space.output_geometry(output).unwrap();
+
         // The target geometry for the positioner should be relative to its parent's geometry, so
         // we will compute that here.
-        let mut target = self.niri.layout.popup_target_rect(window);
+        //
+        // We try to keep regular window popups within the window itself horizontally (since the
+        // window can be scrolled to both edges of the screen), but within the whole monitor's
+        // height.
+        let mut target =
+            Rectangle::from_loc_and_size((0, 0), (window_geo.size.w, output_geo.size.h)).to_f64();
+        target.loc -= self.niri.layout.window_loc(window).unwrap();
         target.loc -= get_popup_toplevel_coords(popup).to_f64();
 
         self.position_popup_within_rect(popup, target);
@@ -1065,7 +971,7 @@ impl State {
 
         // The target geometry for the positioner should be relative to its parent's geometry, so
         // we will compute that here.
-        let mut target = Rectangle::from_size(output_geo.size);
+        let mut target = Rectangle::from_loc_and_size((0, 0), output_geo.size);
         target.loc -= layer_geo.loc;
         target.loc -= get_popup_toplevel_coords(popup);
 
@@ -1110,7 +1016,7 @@ impl State {
         }
     }
 
-    pub fn update_reactive_popups(&self, window: &Window) {
+    pub fn update_reactive_popups(&self, window: &Window, output: &Output) {
         let _span = tracy_client::span!("Niri::update_reactive_popups");
 
         for (popup, _) in PopupManager::popups_for_surface(
@@ -1119,7 +1025,7 @@ impl State {
             match &popup {
                 xdg_popup @ PopupKind::Xdg(popup) => {
                     if popup.with_pending_state(|state| state.positioner.reactive) {
-                        self.unconstrain_window_popup(xdg_popup, window);
+                        self.unconstrain_window_popup(xdg_popup, window, output);
                         if let Err(err) = popup.send_pending_configure() {
                             warn!("error re-configuring reactive popup: {err:?}");
                         }

src/input/backend_ext.rs

@@ -1,51 +0,0 @@
-use ::input as libinput;
-use smithay::backend::input;
-use smithay::backend::winit::WinitVirtualDevice;
-use smithay::output::Output;
-
-use crate::niri::State;
-use crate::protocols::virtual_pointer::VirtualPointer;
-
-pub trait NiriInputBackend: input::InputBackend<Device = Self::NiriDevice> {
-    type NiriDevice: NiriInputDevice;
-}
-impl<T: input::InputBackend> NiriInputBackend for T
-where
-    Self::Device: NiriInputDevice,
-{
-    type NiriDevice = Self::Device;
-}
-
-pub trait NiriInputDevice: input::Device {
-    // FIXME: this should maybe be per-event, not per-device,
-    // but it's not clear that this matters in practice?
-    // it might be more obvious once we implement it for libinput
-    fn output(&self, state: &State) -> Option<Output>;
-}
-
-impl NiriInputDevice for libinput::Device {
-    fn output(&self, _state: &State) -> Option<Output> {
-        // FIXME: Allow specifying the output per-device?
-        None
-    }
-}
-
-impl NiriInputDevice for WinitVirtualDevice {
-    fn output(&self, _state: &State) -> Option<Output> {
-        // FIXME: we should be returning the single output that the winit backend creates,
-        // but for now, that will cause issues because the output is normally upside down,
-        // so we apply Transform::Flipped180 to it and that would also cause
-        // the cursor position to be flipped, which is not what we want.
-        //
-        // instead, we just return None and rely on the fact that it has only one output.
-        // doing so causes the cursor to be placed in *global* output coordinates,
-        // which are not flipped, and happen to be what we want.
-        None
-    }
-}
-
-impl NiriInputDevice for VirtualPointer {
-    fn output(&self, _: &State) -> Option<Output> {
-        self.output().cloned()
-    }
-}

src/input/move_grab.rs

@@ -1,3 +1,5 @@
+use std::time::Duration;
+
 use smithay::backend::input::ButtonState;
 use smithay::desktop::Window;
 use smithay::input::pointer::{
@@ -15,6 +17,7 @@ pub struct MoveGrab {
     start_data: PointerGrabStartData<State>,
     last_location: Point<f64, Logical>,
     window: Window,
+    is_moving: bool,
 }
 
 impl MoveGrab {
@@ -23,6 +26,7 @@ impl MoveGrab {
             last_location: start_data.location,
             start_data,
             window,
+            is_moving: false,
         }
     }
 
@@ -60,6 +64,14 @@ impl PointerGrab<State> for MoveGrab {
                     pos_within_output,
                 );
                 if ongoing {
+                    let timestamp = Duration::from_millis(u64::from(event.time));
+                    if self.is_moving {
+                        data.niri.layout.view_offset_gesture_update(
+                            -event_delta.x,
+                            timestamp,
+                            false,
+                        );
+                    }
                     // FIXME: only redraw the previous and the new output.
                     data.niri.queue_redraw_all();
                     return;
@@ -92,18 +104,27 @@ impl PointerGrab<State> for MoveGrab {
     ) {
         handle.button(data, event);
 
-        // When moving with the left button, right toggles floating, and vice versa.
+        // MouseButton::Middle
-        let toggle_floating_button = if self.start_data.button == 0x110 {
+        if event.button == 0x112 {
-            0x111
+            if event.state == ButtonState::Pressed {
-        } else {
+                let output = data
-            0x110
+                    .niri
-        };
+                    .output_under(handle.current_location())
-        if event.button == toggle_floating_button && event.state == ButtonState::Pressed {
+                    .map(|(output, _)| output)
-            data.niri.layout.toggle_window_floating(Some(&self.window));
+                    .cloned();
+                // FIXME: workspace switch gesture.
+                if let Some(output) = output {
+                    self.is_moving = true;
+                    data.niri.layout.view_offset_gesture_begin(&output, false);
+                }
+            } else if event.state == ButtonState::Released {
+                self.is_moving = false;
+                data.niri.layout.view_offset_gesture_end(false, None);
+            }
         }
 
-        if !handle.current_pressed().contains(&self.start_data.button) {
+        if handle.current_pressed().is_empty() {
-            // The button that initiated the grab was released.
+            // No more buttons are pressed, release the grab.
             handle.unset_grab(self, data, event.serial, event.time, true);
         }
     }

src/ipc/client.rs

@@ -1,6 +1,3 @@
-use std::iter::Peekable;
-use std::slice;
-
 use anyhow::{anyhow, bail, Context};
 use niri_config::OutputName;
 use niri_ipc::socket::Socket;
@@ -26,7 +23,6 @@ pub fn handle_msg(msg: Msg, json: bool) -> anyhow::Result<()> {
         },
         Msg::Workspaces => Request::Workspaces,
         Msg::Windows => Request::Windows,
-        Msg::Layers => Request::Layers,
         Msg::KeyboardLayouts => Request::KeyboardLayouts,
         Msg::EventStream => Request::EventStream,
         Msg::RequestError => Request::ReturnError,
@@ -172,69 +168,6 @@ pub fn handle_msg(msg: Msg, json: bool) -> anyhow::Result<()> {
                 println!();
             }
         }
-        Msg::Layers => {
-            let Response::Layers(mut layers) = response else {
-                bail!("unexpected response: expected Layers, got {response:?}");
-            };
-
-            if json {
-                let layers = serde_json::to_string(&layers).context("error formatting response")?;
-                println!("{layers}");
-                return Ok(());
-            }
-
-            layers.sort_by(|a, b| {
-                Ord::cmp(&a.output, &b.output)
-                    .then_with(|| Ord::cmp(&a.layer, &b.layer))
-                    .then_with(|| Ord::cmp(&a.namespace, &b.namespace))
-            });
-            let mut iter = layers.iter().peekable();
-
-            let print = |surface: &niri_ipc::LayerSurface| {
-                println!("    Surface:");
-                println!("      Namespace: \"{}\"", &surface.namespace);
-
-                let interactivity = match surface.keyboard_interactivity {
-                    niri_ipc::LayerSurfaceKeyboardInteractivity::None => "none",
-                    niri_ipc::LayerSurfaceKeyboardInteractivity::Exclusive => "exclusive",
-                    niri_ipc::LayerSurfaceKeyboardInteractivity::OnDemand => "on-demand",
-                };
-                println!("      Keyboard interactivity: {interactivity}");
-            };
-
-            let print_layer = |iter: &mut Peekable<slice::Iter<niri_ipc::LayerSurface>>,
-                               output: &str,
-                               layer| {
-                let mut empty = true;
-                while let Some(surface) = iter.next_if(|s| s.output == output && s.layer == layer) {
-                    empty = false;
-                    println!();
-                    print(surface);
-                }
-                if empty {
-                    println!(" (empty)\n");
-                } else {
-                    println!();
-                }
-            };
-
-            while let Some(surface) = iter.peek() {
-                let output = &surface.output;
-                println!("Output \"{output}\":");
-
-                print!("  Background layer:");
-                print_layer(&mut iter, output, niri_ipc::Layer::Background);
-
-                print!("  Bottom layer:");
-                print_layer(&mut iter, output, niri_ipc::Layer::Bottom);
-
-                print!("  Top layer:");
-                print_layer(&mut iter, output, niri_ipc::Layer::Top);
-
-                print!("  Overlay layer:");
-                print_layer(&mut iter, output, niri_ipc::Layer::Overlay);
-            }
-        }
         Msg::FocusedOutput => {
             let Response::FocusedOutput(output) = response else {
                 bail!("unexpected response: expected FocusedOutput, got {response:?}");
@@ -516,17 +449,6 @@ fn print_window(window: &Window) {
         println!("  App ID: (unset)");
     }
 
-    println!(
-        "  Is floating: {}",
-        if window.is_floating { "yes" } else { "no" }
-    );
-
-    if let Some(pid) = window.pid {
-        println!("  PID: {pid}");
-    } else {
-        println!("  PID: (unknown)");
-    }
-
     if let Some(workspace_id) = window.workspace_id {
         println!("  Workspace ID: {workspace_id}");
     } else {

src/ipc/server.rs

@@ -1,6 +1,5 @@
 use std::cell::RefCell;
 use std::collections::HashSet;
-use std::ffi::OsStr;
 use std::os::unix::net::{UnixListener, UnixStream};
 use std::path::PathBuf;
 use std::rc::Rc;
@@ -17,11 +16,9 @@ use futures_util::{select_biased, AsyncBufReadExt, AsyncWrite, AsyncWriteExt, Fu
 use niri_config::OutputName;
 use niri_ipc::state::{EventStreamState, EventStreamStatePart as _};
 use niri_ipc::{Event, KeyboardLayouts, OutputConfigChanged, Reply, Request, Response, Workspace};
-use smithay::desktop::layer_map_for_output;
 use smithay::reexports::calloop::generic::Generic;
 use smithay::reexports::calloop::{Interest, LoopHandle, Mode, PostAction};
 use smithay::reexports::rustix::fs::unlink;
-use smithay::wayland::shell::wlr_layer::{KeyboardInteractivity, Layer};
 
 use crate::backend::IpcOutputMap;
 use crate::layout::workspace::WorkspaceId;
@@ -34,10 +31,7 @@ use crate::window::Mapped;
 const EVENT_STREAM_BUFFER_SIZE: usize = 64;
 
 pub struct IpcServer {
-    /// Path to the IPC socket.
+    pub socket_path: PathBuf,
-    ///
-    /// This is `None` when creating `IpcServer` without a socket.
-    pub socket_path: Option<PathBuf>,
     event_streams: Rc<RefCell<Vec<EventStreamSender>>>,
     event_stream_state: Rc<RefCell<EventStreamState>>,
 }
@@ -64,12 +58,10 @@ struct EventStreamSender {
 impl IpcServer {
     pub fn start(
         event_loop: &LoopHandle<'static, State>,
-        wayland_socket_name: Option<&OsStr>,
+        wayland_socket_name: &str,
     ) -> anyhow::Result<Self> {
         let _span = tracy_client::span!("Ipc::start");
 
-        let socket_path = if let Some(wayland_socket_name) = wayland_socket_name {
-            let wayland_socket_name = wayland_socket_name.to_string_lossy();
         let socket_name = format!("niri.{wayland_socket_name}.{}.sock", process::id());
         let mut socket_path = socket_dir();
         socket_path.push(socket_name);
@@ -92,11 +84,6 @@ impl IpcServer {
             })
             .unwrap();
 
-            Some(socket_path)
-        } else {
-            None
-        };
-
         Ok(Self {
             socket_path,
             event_streams: Rc::new(RefCell::new(Vec::new())),
@@ -130,9 +117,7 @@ impl IpcServer {
 
 impl Drop for IpcServer {
     fn drop(&mut self) {
-        if let Some(socket_path) = &self.socket_path {
+        let _ = unlink(&self.socket_path);
-            let _ = unlink(socket_path);
-        }
     }
 }
 
@@ -269,47 +254,6 @@ async fn process(ctx: &ClientCtx, request: Request) -> Reply {
             let windows = state.windows.windows.values().cloned().collect();
             Response::Windows(windows)
         }
-        Request::Layers => {
-            let (tx, rx) = async_channel::bounded(1);
-            ctx.event_loop.insert_idle(move |state| {
-                let mut layers = Vec::new();
-                for output in state.niri.global_space.outputs() {
-                    let name = output.name();
-                    for surface in layer_map_for_output(output).layers() {
-                        let layer = match surface.layer() {
-                            Layer::Background => niri_ipc::Layer::Background,
-                            Layer::Bottom => niri_ipc::Layer::Bottom,
-                            Layer::Top => niri_ipc::Layer::Top,
-                            Layer::Overlay => niri_ipc::Layer::Overlay,
-                        };
-                        let keyboard_interactivity =
-                            match surface.cached_state().keyboard_interactivity {
-                                KeyboardInteractivity::None => {
-                                    niri_ipc::LayerSurfaceKeyboardInteractivity::None
-                                }
-                                KeyboardInteractivity::Exclusive => {
-                                    niri_ipc::LayerSurfaceKeyboardInteractivity::Exclusive
-                                }
-                                KeyboardInteractivity::OnDemand => {
-                                    niri_ipc::LayerSurfaceKeyboardInteractivity::OnDemand
-                                }
-                            };
-
-                        layers.push(niri_ipc::LayerSurface {
-                            namespace: surface.namespace().to_owned(),
-                            output: name.clone(),
-                            layer,
-                            keyboard_interactivity,
-                        });
-                    }
-                }
-
-                let _ = tx.send_blocking(layers);
-            });
-            let result = rx.recv().await;
-            let layers = result.map_err(|_| String::from("error getting layers info"))?;
-            Response::Layers(layers)
-        }
         Request::KeyboardLayouts => {
             let state = ctx.event_stream_state.borrow();
             let layout = state.keyboard_layouts.keyboard_layouts.clone();
@@ -327,9 +271,6 @@ async fn process(ctx: &ClientCtx, request: Request) -> Reply {
 
             let action = niri_config::Action::from(action);
             ctx.event_loop.insert_idle(move |state| {
-                // Make sure some logic like workspace clean-up has a chance to run before doing
-                // actions.
-                state.niri.advance_animations();
                 state.do_action(action, false);
                 let _ = tx.send_blocking(());
             });
@@ -422,10 +363,8 @@ fn make_ipc_window(mapped: &Mapped, workspace_id: Option<WorkspaceId>) -> niri_i
         id: mapped.id().get(),
         title: role.title.clone(),
         app_id: role.app_id.clone(),
-        pid: mapped.credentials().map(|c| c.pid),
         workspace_id: workspace_id.map(|id| id.get()),
         is_focused: mapped.is_focused(),
-        is_floating: mapped.is_floating(),
     })
 }
 
@@ -536,7 +475,7 @@ impl State {
             }
 
             // Check if this workspace became active.
-            let is_active = mon.is_some_and(|mon| mon.active_workspace_idx() == ws_idx);
+            let is_active = mon.map_or(false, |mon| mon.active_workspace_idx() == ws_idx);
             if is_active && !ipc_ws.is_active {
                 events.push(Event::WorkspaceActivated { id, focused: false });
             }
@@ -559,7 +498,7 @@ impl State {
                         idx: u8::try_from(ws_idx + 1).unwrap_or(u8::MAX),
                         name: ws.name().cloned(),
                         output: mon.map(|mon| mon.output_name().clone()),
-                        is_active: mon.is_some_and(|mon| mon.active_workspace_idx() == ws_idx),
+                        is_active: mon.map_or(false, |mon| mon.active_workspace_idx() == ws_idx),
                         is_focused: Some(id) == focused_ws_id,
                         active_window_id: ws.active_window().map(|win| win.id().get()),
                     }
@@ -606,8 +545,7 @@ impl State {
             };
 
             let workspace_id = ws_id.map(|id| id.get());
-            let mut changed =
+            let mut changed = ipc_win.workspace_id != workspace_id;
-                ipc_win.workspace_id != workspace_id || ipc_win.is_floating != mapped.is_floating();
 
             changed |= with_toplevel_role(mapped.toplevel(), |role| {
                 ipc_win.title != role.title || ipc_win.app_id != role.app_id

src/layer/mapped.rs

@@ -1,157 +0,0 @@
-use niri_config::layer_rule::LayerRule;
-use niri_config::Config;
-use smithay::backend::renderer::element::surface::{
-    render_elements_from_surface_tree, WaylandSurfaceRenderElement,
-};
-use smithay::backend::renderer::element::Kind;
-use smithay::desktop::{LayerSurface, PopupManager};
-use smithay::utils::{Logical, Point, Scale, Size};
-
-use super::ResolvedLayerRules;
-use crate::layout::shadow::Shadow;
-use crate::niri_render_elements;
-use crate::render_helpers::renderer::NiriRenderer;
-use crate::render_helpers::shadow::ShadowRenderElement;
-use crate::render_helpers::solid_color::{SolidColorBuffer, SolidColorRenderElement};
-use crate::render_helpers::{RenderTarget, SplitElements};
-
-#[derive(Debug)]
-pub struct MappedLayer {
-    /// The surface itself.
-    surface: LayerSurface,
-
-    /// Up-to-date rules.
-    rules: ResolvedLayerRules,
-
-    /// Buffer to draw instead of the surface when it should be blocked out.
-    block_out_buffer: SolidColorBuffer,
-
-    /// The shadow around the surface.
-    shadow: Shadow,
-}
-
-niri_render_elements! {
-    LayerSurfaceRenderElement<R> => {
-        Wayland = WaylandSurfaceRenderElement<R>,
-        SolidColor = SolidColorRenderElement,
-        Shadow = ShadowRenderElement,
-    }
-}
-
-impl MappedLayer {
-    pub fn new(surface: LayerSurface, rules: ResolvedLayerRules, config: &Config) -> Self {
-        let mut shadow_config = config.layout.shadow;
-        // Shadows for layer surfaces need to be explicitly enabled.
-        shadow_config.on = false;
-        let shadow_config = rules.shadow.resolve_against(shadow_config);
-
-        Self {
-            surface,
-            rules,
-            block_out_buffer: SolidColorBuffer::new((0., 0.), [0., 0., 0., 1.]),
-            shadow: Shadow::new(shadow_config),
-        }
-    }
-
-    pub fn update_config(&mut self, config: &Config) {
-        let mut shadow_config = config.layout.shadow;
-        // Shadows for layer surfaces need to be explicitly enabled.
-        shadow_config.on = false;
-        let shadow_config = self.rules.shadow.resolve_against(shadow_config);
-        self.shadow.update_config(shadow_config);
-    }
-
-    pub fn update_shaders(&mut self) {
-        self.shadow.update_shaders();
-    }
-
-    pub fn update_render_elements(&mut self, size: Size<f64, Logical>, scale: Scale<f64>) {
-        // Round to physical pixels.
-        let size = size.to_physical_precise_round(scale).to_logical(scale);
-
-        self.block_out_buffer.resize(size);
-
-        let radius = self.rules.geometry_corner_radius.unwrap_or_default();
-        // FIXME: is_active based on keyboard focus?
-        self.shadow
-            .update_render_elements(size, true, radius, scale.x, 1.);
-    }
-
-    pub fn surface(&self) -> &LayerSurface {
-        &self.surface
-    }
-
-    pub fn rules(&self) -> &ResolvedLayerRules {
-        &self.rules
-    }
-
-    /// Recomputes the resolved layer rules and returns whether they changed.
-    pub fn recompute_layer_rules(&mut self, rules: &[LayerRule], is_at_startup: bool) -> bool {
-        let new_rules = ResolvedLayerRules::compute(rules, &self.surface, is_at_startup);
-        if new_rules == self.rules {
-            return false;
-        }
-
-        self.rules = new_rules;
-        true
-    }
-
-    pub fn render<R: NiriRenderer>(
-        &self,
-        renderer: &mut R,
-        location: Point<f64, Logical>,
-        scale: Scale<f64>,
-        target: RenderTarget,
-    ) -> SplitElements<LayerSurfaceRenderElement<R>> {
-        let mut rv = SplitElements::default();
-
-        let alpha = self.rules.opacity.unwrap_or(1.).clamp(0., 1.);
-
-        if target.should_block_out(self.rules.block_out_from) {
-            // Round to physical pixels.
-            let location = location.to_physical_precise_round(scale).to_logical(scale);
-
-            // FIXME: take geometry-corner-radius into account.
-            let elem = SolidColorRenderElement::from_buffer(
-                &self.block_out_buffer,
-                location,
-                alpha,
-                Kind::Unspecified,
-            );
-            rv.normal.push(elem.into());
-        } else {
-            // Layer surfaces don't have extra geometry like windows.
-            let buf_pos = location;
-
-            let surface = self.surface.wl_surface();
-            for (popup, popup_offset) in PopupManager::popups_for_surface(surface) {
-                // Layer surfaces don't have extra geometry like windows.
-                let offset = popup_offset - popup.geometry().loc;
-
-                rv.popups.extend(render_elements_from_surface_tree(
-                    renderer,
-                    popup.wl_surface(),
-                    (buf_pos + offset.to_f64()).to_physical_precise_round(scale),
-                    scale,
-                    alpha,
-                    Kind::Unspecified,
-                ));
-            }
-
-            rv.normal = render_elements_from_surface_tree(
-                renderer,
-                surface,
-                buf_pos.to_physical_precise_round(scale),
-                scale,
-                alpha,
-                Kind::Unspecified,
-            );
-        }
-
-        let location = location.to_physical_precise_round(scale).to_logical(scale);
-        rv.normal
-            .extend(self.shadow.render(renderer, location).map(Into::into));
-
-        rv
-    }
-}

src/layer/mod.rs

@@ -1,92 +0,0 @@
-use niri_config::layer_rule::{LayerRule, Match};
-use niri_config::{BlockOutFrom, CornerRadius, ShadowRule};
-use smithay::desktop::LayerSurface;
-
-pub mod mapped;
-pub use mapped::MappedLayer;
-
-/// Rules fully resolved for a layer-shell surface.
-#[derive(Debug, PartialEq)]
-pub struct ResolvedLayerRules {
-    /// Extra opacity to draw this layer surface with.
-    pub opacity: Option<f32>,
-
-    /// Whether to block out this layer surface from certain render targets.
-    pub block_out_from: Option<BlockOutFrom>,
-
-    /// Shadow overrides.
-    pub shadow: ShadowRule,
-
-    /// Corner radius to assume this layer surface has.
-    pub geometry_corner_radius: Option<CornerRadius>,
-}
-
-impl ResolvedLayerRules {
-    pub const fn empty() -> Self {
-        Self {
-            opacity: None,
-            block_out_from: None,
-            shadow: ShadowRule {
-                off: false,
-                on: false,
-                offset: None,
-                softness: None,
-                spread: None,
-                draw_behind_window: None,
-                color: None,
-                inactive_color: None,
-            },
-            geometry_corner_radius: None,
-        }
-    }
-
-    pub fn compute(rules: &[LayerRule], surface: &LayerSurface, is_at_startup: bool) -> Self {
-        let _span = tracy_client::span!("ResolvedLayerRules::compute");
-
-        let mut resolved = ResolvedLayerRules::empty();
-
-        for rule in rules {
-            let matches = |m: &Match| {
-                if let Some(at_startup) = m.at_startup {
-                    if at_startup != is_at_startup {
-                        return false;
-                    }
-                }
-
-                surface_matches(surface, m)
-            };
-
-            if !(rule.matches.is_empty() || rule.matches.iter().any(matches)) {
-                continue;
-            }
-
-            if rule.excludes.iter().any(matches) {
-                continue;
-            }
-
-            if let Some(x) = rule.opacity {
-                resolved.opacity = Some(x);
-            }
-            if let Some(x) = rule.block_out_from {
-                resolved.block_out_from = Some(x);
-            }
-            if let Some(x) = rule.geometry_corner_radius {
-                resolved.geometry_corner_radius = Some(x);
-            }
-
-            resolved.shadow.merge_with(&rule.shadow);
-        }
-
-        resolved
-    }
-}
-
-fn surface_matches(surface: &LayerSurface, m: &Match) -> bool {
-    if let Some(namespace_re) = &m.namespace {
-        if !namespace_re.0.is_match(surface.namespace()) {
-            return false;
-        }
-    }
-
-    true
-}

src/layout/closing_window.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::time::Duration;
 
 use anyhow::Context as _;
 use glam::{Mat3, Vec2};
@@ -137,15 +138,16 @@ impl ClosingWindow {
         })
     }
 
-    pub fn advance_animations(&mut self) {
+    pub fn advance_animations(&mut self, current_time: Duration) {
         match &mut self.anim_state {
             AnimationState::Waiting { blocker, anim } => {
                 if blocker.state() != BlockerState::Pending {
-                    let anim = anim.restarted(0., 1., 0.);
+                    let mut anim = anim.restarted(0., 1., 0.);
+                    anim.set_current_time(current_time);
                     self.anim_state = AnimationState::Animating(anim);
                 }
             }
-            AnimationState::Animating(_anim) => (),
+            AnimationState::Animating(anim) => anim.set_current_time(current_time),
         }
     }
 

src/layout/focus_ring.rs

@@ -1,8 +1,8 @@
 use std::iter::zip;
 
 use arrayvec::ArrayVec;
-use niri_config::{CornerRadius, Gradient, GradientRelativeTo};
+use niri_config::{CornerRadius, Gradient, GradientInterpolation, GradientRelativeTo};
-use smithay::backend::renderer::element::{Element as _, Kind};
+use smithay::backend::renderer::element::Kind;
 use smithay::utils::{Logical, Point, Rectangle, Size};
 
 use crate::niri_render_elements;
@@ -53,7 +53,6 @@ impl FocusRing {
         }
     }
 
-    #[allow(clippy::too_many_arguments)]
     pub fn update_render_elements(
         &mut self,
         win_size: Size<f64, Logical>,
@@ -62,7 +61,6 @@ impl FocusRing {
         view_rect: Rectangle<f64, Logical>,
         radius: CornerRadius,
         scale: f64,
-        alpha: f32,
     ) {
         let width = self.config.width.0;
         self.full_size = win_size + Size::from((width, width)).upscale(2.);
@@ -88,9 +86,15 @@ impl FocusRing {
         self.use_border_shader = radius != CornerRadius::default() || gradient.is_some();
 
         // Set the defaults for solid color + rounded corners.
-        let gradient = gradient.unwrap_or_else(|| Gradient::from(color));
+        let gradient = gradient.unwrap_or(Gradient {
+            from: color,
+            to: color,
+            angle: 0,
+            relative_to: GradientRelativeTo::Window,
+            in_: GradientInterpolation::default(),
+        });
 
-        let full_rect = Rectangle::new(Point::from((-width, -width)), self.full_size);
+        let full_rect = Rectangle::from_loc_and_size((-width, -width), self.full_size);
         let gradient_area = match gradient.relative_to {
             GradientRelativeTo::Window => full_rect,
             GradientRelativeTo::WorkspaceView => view_rect,
@@ -174,16 +178,15 @@ impl FocusRing {
             for (border, (loc, size)) in zip(&mut self.borders, zip(self.locations, self.sizes)) {
                 border.update(
                     size,
-                    Rectangle::new(gradient_area.loc - loc, gradient_area.size),
+                    Rectangle::from_loc_and_size(gradient_area.loc - loc, gradient_area.size),
                     gradient.in_,
                     gradient.from,
                     gradient.to,
                     ((gradient.angle as f32) - 90.).to_radians(),
-                    Rectangle::new(full_rect.loc - loc, full_rect.size),
+                    Rectangle::from_loc_and_size(full_rect.loc - loc, full_rect.size),
                     rounded_corner_border_width,
                     radius,
                     scale as f32,
-                    alpha,
                 );
             }
         } else {
@@ -193,16 +196,18 @@ impl FocusRing {
 
             self.borders[0].update(
                 self.sizes[0],
-                Rectangle::new(gradient_area.loc - self.locations[0], gradient_area.size),
+                Rectangle::from_loc_and_size(
+                    gradient_area.loc - self.locations[0],
+                    gradient_area.size,
+                ),
                 gradient.in_,
                 gradient.from,
                 gradient.to,
                 ((gradient.angle as f32) - 90.).to_radians(),
-                Rectangle::new(full_rect.loc - self.locations[0], full_rect.size),
+                Rectangle::from_loc_and_size(full_rect.loc - self.locations[0], full_rect.size),
                 rounded_corner_border_width,
                 radius,
                 scale as f32,
-                alpha,
             );
         }
 
@@ -233,9 +238,7 @@ impl FocusRing {
             let elem = if self.use_border_shader && has_border_shader {
                 border.clone().with_location(location).into()
             } else {
-                let alpha = border.alpha();
+                SolidColorRenderElement::from_buffer(buffer, location, 1., Kind::Unspecified).into()
-                SolidColorRenderElement::from_buffer(buffer, location, alpha, Kind::Unspecified)
-                    .into()
             };
             rv.push(elem);
         };
@@ -262,8 +265,4 @@ impl FocusRing {
     pub fn is_off(&self) -> bool {
         self.config.off
     }
-
-    pub fn config(&self) -> &niri_config::FocusRing {
-        &self.config
-    }
 }

src/layout/insert_hint_element.rs

@@ -48,7 +48,7 @@ impl InsertHintElement {
         scale: f64,
     ) {
         self.inner
-            .update_render_elements(size, true, false, view_rect, radius, scale, 1.);
+            .update_render_elements(size, true, false, view_rect, radius, scale);
     }
 
     pub fn render(

src/layout/opening_window.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::time::Duration;
 
 use anyhow::Context as _;
 use glam::{Mat3, Vec2};
@@ -40,7 +41,9 @@ impl OpenAnimation {
         }
     }
 
-    pub fn advance_animations(&mut self) {}
+    pub fn advance_animations(&mut self, current_time: Duration) {
+        self.anim.set_current_time(current_time);
+    }
 
     pub fn is_done(&self) -> bool {
         self.anim.is_done()
@@ -72,7 +75,7 @@ impl OpenAnimation {
         let texture_size = geo.size.to_f64().to_logical(scale);
 
         if Shaders::get(renderer).program(ProgramType::Open).is_some() {
-            let mut area = Rectangle::new(location + offset, texture_size);
+            let mut area = Rectangle::from_loc_and_size(location + offset, texture_size);
 
             // Expand the area a bit to allow for more varied effects.
             let mut target_size = area.size.upscale(1.5);

src/layout/shadow.rs

@@ -1,178 +0,0 @@
-use std::iter::zip;
-
-use niri_config::CornerRadius;
-use smithay::utils::{Logical, Point, Rectangle, Size};
-
-use crate::render_helpers::renderer::NiriRenderer;
-use crate::render_helpers::shadow::ShadowRenderElement;
-
-#[derive(Debug)]
-pub struct Shadow {
-    shader_rects: Vec<Rectangle<f64, Logical>>,
-    shaders: Vec<ShadowRenderElement>,
-    config: niri_config::Shadow,
-}
-
-impl Shadow {
-    pub fn new(config: niri_config::Shadow) -> Self {
-        Self {
-            shader_rects: Vec::new(),
-            shaders: Vec::new(),
-            config,
-        }
-    }
-
-    pub fn update_config(&mut self, config: niri_config::Shadow) {
-        self.config = config;
-    }
-
-    pub fn update_shaders(&mut self) {
-        for elem in &mut self.shaders {
-            elem.damage_all();
-        }
-    }
-
-    pub fn update_render_elements(
-        &mut self,
-        win_size: Size<f64, Logical>,
-        is_active: bool,
-        radius: CornerRadius,
-        scale: f64,
-        alpha: f32,
-    ) {
-        let ceil = |logical: f64| (logical * scale).ceil() / scale;
-
-        // All of this stuff should end up aligned to physical pixels because:
-        // * Window size is rounded to physical pixels before being passed to this function.
-        // * We will ceil the corner radii below.
-        // * We do not divide anything, only add, subtract and multiply by integers.
-        // * At rendering time, tile positions are rounded to physical pixels.
-
-        let width = self.config.softness.0;
-        // Like in CSS box-shadow.
-        let sigma = width / 2.;
-        // Adjust width to draw all necessary pixels.
-        let width = ceil(sigma * 3.);
-
-        let offset = self.config.offset;
-        let offset = Point::from((ceil(offset.x.0), ceil(offset.y.0)));
-
-        let spread = ceil(self.config.spread.0);
-        let offset = offset - Point::from((spread, spread));
-
-        let win_radius = radius.fit_to(win_size.w as f32, win_size.h as f32);
-
-        let box_size = win_size + Size::from((spread, spread)).upscale(2.);
-        let radius = win_radius.expanded_by(spread as f32);
-
-        let shader_size = box_size + Size::from((width, width)).upscale(2.);
-
-        let color = if is_active {
-            self.config.color
-        } else {
-            // Default to slightly more transparent.
-            self.config
-                .inactive_color
-                .unwrap_or(self.config.color * 0.75)
-        };
-
-        let shader_geo = Rectangle::new(Point::from((-width, -width)), shader_size);
-
-        // This is actually offset relative to shader_geo, this is handled below.
-        let window_geo = Rectangle::new(Point::from((0., 0.)), win_size);
-
-        if !self.config.draw_behind_window {
-            let top_left = ceil(f64::from(win_radius.top_left));
-            let top_right = f64::min(win_size.w - top_left, ceil(f64::from(win_radius.top_right)));
-            let bottom_left = f64::min(
-                win_size.h - top_left,
-                ceil(f64::from(win_radius.bottom_left)),
-            );
-            let bottom_right = f64::min(
-                win_size.h - top_right,
-                f64::min(
-                    win_size.w - bottom_left,
-                    ceil(f64::from(win_radius.bottom_right)),
-                ),
-            );
-
-            let top_left = Rectangle::new(Point::from((0., 0.)), Size::from((top_left, top_left)));
-            let top_right = Rectangle::new(
-                Point::from((win_size.w - top_right, 0.)),
-                Size::from((top_right, top_right)),
-            );
-            let bottom_right = Rectangle::new(
-                Point::from((win_size.w - bottom_right, win_size.h - bottom_right)),
-                Size::from((bottom_right, bottom_right)),
-            );
-            let bottom_left = Rectangle::new(
-                Point::from((0., win_size.h - bottom_left)),
-                Size::from((bottom_left, bottom_left)),
-            );
-
-            let mut background =
-                window_geo.subtract_rects([top_left, top_right, bottom_right, bottom_left]);
-            for rect in &mut background {
-                rect.loc -= offset;
-            }
-
-            self.shader_rects = shader_geo.subtract_rects(background);
-            self.shaders
-                .resize_with(self.shader_rects.len(), Default::default);
-
-            for (shader, rect) in zip(&mut self.shaders, &mut self.shader_rects) {
-                shader.update(
-                    rect.size,
-                    Rectangle::new(rect.loc.upscale(-1.), box_size),
-                    color,
-                    sigma as f32,
-                    radius,
-                    scale as f32,
-                    Rectangle::new(window_geo.loc - offset - rect.loc, window_geo.size),
-                    win_radius,
-                    alpha,
-                );
-
-                rect.loc += offset;
-            }
-        } else {
-            self.shader_rects.resize_with(1, Default::default);
-            self.shader_rects[0] = shader_geo;
-
-            self.shaders.resize_with(1, Default::default);
-            self.shaders[0].update(
-                shader_geo.size,
-                Rectangle::new(shader_geo.loc.upscale(-1.), box_size),
-                color,
-                sigma as f32,
-                radius,
-                scale as f32,
-                Rectangle::zero(),
-                Default::default(),
-                alpha,
-            );
-
-            self.shader_rects[0].loc += offset;
-        }
-    }
-
-    pub fn render(
-        &self,
-        renderer: &mut impl NiriRenderer,
-        location: Point<f64, Logical>,
-    ) -> impl Iterator<Item = ShadowRenderElement> + '_ {
-        if !self.config.on {
-            return None.into_iter().flatten();
-        }
-
-        let has_shadow_shader = ShadowRenderElement::has_shader(renderer);
-        if !has_shadow_shader {
-            return None.into_iter().flatten();
-        }
-
-        let rv = zip(&self.shaders, &self.shader_rects)
-            .map(move |(shader, rect)| shader.clone().with_location(location + rect.loc));
-
-        Some(rv).into_iter().flatten()
-    }
-}

src/layout/tab_indicator.rs

@@ -1,401 +0,0 @@
-use std::iter::zip;
-use std::mem;
-
-use niri_config::{CornerRadius, Gradient, GradientRelativeTo, TabIndicatorPosition};
-use smithay::utils::{Logical, Point, Rectangle, Size};
-
-use super::tile::Tile;
-use super::LayoutElement;
-use crate::animation::{Animation, Clock};
-use crate::niri_render_elements;
-use crate::render_helpers::border::BorderRenderElement;
-use crate::render_helpers::renderer::NiriRenderer;
-use crate::utils::{floor_logical_in_physical_max1, round_logical_in_physical};
-
-#[derive(Debug)]
-pub struct TabIndicator {
-    shader_locs: Vec<Point<f64, Logical>>,
-    shaders: Vec<BorderRenderElement>,
-    open_anim: Option<Animation>,
-    config: niri_config::TabIndicator,
-}
-
-#[derive(Debug)]
-pub struct TabInfo {
-    /// Gradient for the tab indicator.
-    pub gradient: Gradient,
-    /// Tab geometry in the same coordinate system as the area.
-    pub geometry: Rectangle<f64, Logical>,
-}
-
-niri_render_elements! {
-    TabIndicatorRenderElement => {
-        Gradient = BorderRenderElement,
-    }
-}
-
-impl TabIndicator {
-    pub fn new(config: niri_config::TabIndicator) -> Self {
-        Self {
-            shader_locs: Vec::new(),
-            shaders: Vec::new(),
-            open_anim: None,
-            config,
-        }
-    }
-
-    pub fn update_config(&mut self, config: niri_config::TabIndicator) {
-        self.config = config;
-    }
-
-    pub fn update_shaders(&mut self) {
-        for elem in &mut self.shaders {
-            elem.damage_all();
-        }
-    }
-
-    pub fn advance_animations(&mut self) {
-        if let Some(anim) = &mut self.open_anim {
-            if anim.is_done() {
-                self.open_anim = None;
-            }
-        }
-    }
-
-    pub fn are_animations_ongoing(&self) -> bool {
-        self.open_anim.is_some()
-    }
-
-    pub fn start_open_animation(&mut self, clock: Clock, config: niri_config::Animation) {
-        self.open_anim = Some(Animation::new(clock, 0., 1., 0., config));
-    }
-
-    fn tab_rects(
-        &self,
-        area: Rectangle<f64, Logical>,
-        count: usize,
-        scale: f64,
-    ) -> impl Iterator<Item = Rectangle<f64, Logical>> {
-        let round = |logical: f64| round_logical_in_physical(scale, logical);
-
-        let progress = self.open_anim.as_ref().map_or(1., |a| a.value().max(0.));
-
-        let width = round(self.config.width.0);
-        let gap = round(self.config.gap.0);
-        let gaps_between = round(self.config.gaps_between_tabs.0);
-
-        let position = self.config.position;
-        let side = match position {
-            TabIndicatorPosition::Left | TabIndicatorPosition::Right => area.size.h,
-            TabIndicatorPosition::Top | TabIndicatorPosition::Bottom => area.size.w,
-        };
-        let total_prop = self.config.length.total_proportion.unwrap_or(0.5);
-        let min_length = round(side * total_prop.clamp(0., 2.));
-
-        // Compute px_per_tab before applying the animation to gaps_between in order to avoid it
-        // growing and shrinking over the duration of the animation.
-        let pixel = 1. / scale;
-        let shortest_length = count as f64 * (pixel + gaps_between) - gaps_between;
-        let length = f64::max(min_length, shortest_length);
-        let px_per_tab = (length + gaps_between) / count as f64 - gaps_between;
-
-        let px_per_tab = px_per_tab * progress;
-        let gaps_between = round(self.config.gaps_between_tabs.0 * progress);
-
-        let length = count as f64 * (px_per_tab + gaps_between) - gaps_between;
-        let px_per_tab = floor_logical_in_physical_max1(scale, px_per_tab);
-        let floored_length = count as f64 * (px_per_tab + gaps_between) - gaps_between;
-        let mut ones_left = ((length - floored_length) / pixel).round() as usize;
-
-        let mut shader_loc = Point::from((-gap - width, round((side - length) / 2.)));
-        match position {
-            TabIndicatorPosition::Left => (),
-            TabIndicatorPosition::Right => shader_loc.x = area.size.w + gap,
-            TabIndicatorPosition::Top => mem::swap(&mut shader_loc.x, &mut shader_loc.y),
-            TabIndicatorPosition::Bottom => {
-                shader_loc.x = shader_loc.y;
-                shader_loc.y = area.size.h + gap;
-            }
-        }
-        shader_loc += area.loc;
-
-        (0..count).map(move |_| {
-            let mut px_per_tab = px_per_tab;
-            if ones_left > 0 {
-                ones_left -= 1;
-                px_per_tab += pixel;
-            }
-
-            let loc = shader_loc;
-
-            match position {
-                TabIndicatorPosition::Left | TabIndicatorPosition::Right => {
-                    shader_loc.y += px_per_tab + gaps_between
-                }
-                TabIndicatorPosition::Top | TabIndicatorPosition::Bottom => {
-                    shader_loc.x += px_per_tab + gaps_between
-                }
-            }
-
-            let size = match position {
-                TabIndicatorPosition::Left | TabIndicatorPosition::Right => {
-                    Size::from((width, px_per_tab))
-                }
-                TabIndicatorPosition::Top | TabIndicatorPosition::Bottom => {
-                    Size::from((px_per_tab, width))
-                }
-            };
-
-            Rectangle::new(loc, size)
-        })
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub fn update_render_elements(
-        &mut self,
-        enabled: bool,
-        // Geometry of the tabs area.
-        area: Rectangle<f64, Logical>,
-        // View rect relative to the tabs area.
-        area_view_rect: Rectangle<f64, Logical>,
-        // Tab count, should match the tabs iterator length.
-        tab_count: usize,
-        tabs: impl Iterator<Item = TabInfo>,
-        is_active: bool,
-        scale: f64,
-    ) {
-        if !enabled || self.config.off {
-            self.shader_locs.clear();
-            self.shaders.clear();
-            return;
-        }
-
-        let count = tab_count;
-        if self.config.hide_when_single_tab && count == 1 {
-            self.shader_locs.clear();
-            self.shaders.clear();
-            return;
-        }
-
-        self.shaders.resize_with(count, Default::default);
-        self.shader_locs.resize_with(count, Default::default);
-
-        let position = self.config.position;
-        let radius = self.config.corner_radius.0 as f32;
-        let shared_rounded_corners = self.config.gaps_between_tabs.0 == 0.;
-        let mut tabs_left = tab_count;
-
-        let rects = self.tab_rects(area, count, scale);
-        for ((shader, loc), (tab, rect)) in zip(
-            zip(&mut self.shaders, &mut self.shader_locs),
-            zip(tabs, rects),
-        ) {
-            *loc = rect.loc;
-
-            let mut gradient_area = match tab.gradient.relative_to {
-                GradientRelativeTo::Window => tab.geometry,
-                GradientRelativeTo::WorkspaceView => area_view_rect,
-            };
-            gradient_area.loc -= *loc;
-
-            let mut color_from = tab.gradient.from;
-            let mut color_to = tab.gradient.to;
-            if !is_active {
-                color_from *= 0.5;
-                color_to *= 0.5;
-            }
-
-            let radius = if shared_rounded_corners && tab_count > 1 {
-                if tabs_left == tab_count {
-                    // First tab.
-                    match position {
-                        TabIndicatorPosition::Left | TabIndicatorPosition::Right => CornerRadius {
-                            top_left: radius,
-                            top_right: radius,
-                            bottom_right: 0.,
-                            bottom_left: 0.,
-                        },
-                        TabIndicatorPosition::Top | TabIndicatorPosition::Bottom => CornerRadius {
-                            top_left: radius,
-                            top_right: 0.,
-                            bottom_right: 0.,
-                            bottom_left: radius,
-                        },
-                    }
-                } else if tabs_left == 1 {
-                    // Last tab.
-                    match position {
-                        TabIndicatorPosition::Left | TabIndicatorPosition::Right => CornerRadius {
-                            top_left: 0.,
-                            top_right: 0.,
-                            bottom_right: radius,
-                            bottom_left: radius,
-                        },
-                        TabIndicatorPosition::Top | TabIndicatorPosition::Bottom => CornerRadius {
-                            top_left: 0.,
-                            top_right: radius,
-                            bottom_right: radius,
-                            bottom_left: 0.,
-                        },
-                    }
-                } else {
-                    // Tab in the middle.
-                    CornerRadius::default()
-                }
-            } else {
-                // Separate tabs, or the only tab.
-                CornerRadius::from(radius)
-            };
-            let radius = radius.fit_to(rect.size.w as f32, rect.size.h as f32);
-            tabs_left -= 1;
-
-            shader.update(
-                rect.size,
-                gradient_area,
-                tab.gradient.in_,
-                color_from,
-                color_to,
-                ((tab.gradient.angle as f32) - 90.).to_radians(),
-                Rectangle::from_size(rect.size),
-                0.,
-                radius,
-                scale as f32,
-                1.,
-            );
-        }
-    }
-
-    pub fn hit(
-        &self,
-        area: Rectangle<f64, Logical>,
-        tab_count: usize,
-        scale: f64,
-        point: Point<f64, Logical>,
-    ) -> Option<usize> {
-        if self.config.off {
-            return None;
-        }
-
-        let count = tab_count;
-        if self.config.hide_when_single_tab && count == 1 {
-            return None;
-        }
-
-        self.tab_rects(area, count, scale)
-            .enumerate()
-            .find_map(|(idx, rect)| rect.contains(point).then_some(idx))
-    }
-
-    pub fn render(
-        &self,
-        renderer: &mut impl NiriRenderer,
-        pos: Point<f64, Logical>,
-    ) -> impl Iterator<Item = TabIndicatorRenderElement> + '_ {
-        let has_border_shader = BorderRenderElement::has_shader(renderer);
-        if !has_border_shader {
-            return None.into_iter().flatten();
-        }
-
-        let rv = zip(&self.shaders, &self.shader_locs)
-            .map(move |(shader, loc)| shader.clone().with_location(pos + *loc))
-            .map(TabIndicatorRenderElement::from);
-
-        Some(rv).into_iter().flatten()
-    }
-
-    /// Extra size occupied by the tab indicator.
-    pub fn extra_size(&self, tab_count: usize, scale: f64) -> Size<f64, Logical> {
-        if self.config.off
-            || !self.config.place_within_column
-            || (self.config.hide_when_single_tab && tab_count == 1)
-        {
-            return Size::from((0., 0.));
-        }
-
-        let round = |logical: f64| round_logical_in_physical(scale, logical);
-        let width = round(self.config.width.0);
-        let gap = round(self.config.gap.0);
-
-        // No, I am *not* falling into the rabbit hole of "what if the tab indicator is wide enough
-        // that it peeks from the other side of the window".
-        let size = f64::max(0., width + gap);
-
-        match self.config.position {
-            TabIndicatorPosition::Left | TabIndicatorPosition::Right => Size::from((size, 0.)),
-            TabIndicatorPosition::Top | TabIndicatorPosition::Bottom => Size::from((0., size)),
-        }
-    }
-
-    /// Offset of the tabbed content due to space occupied by the tab indicator.
-    pub fn content_offset(&self, tab_count: usize, scale: f64) -> Point<f64, Logical> {
-        match self.config.position {
-            TabIndicatorPosition::Left | TabIndicatorPosition::Top => {
-                self.extra_size(tab_count, scale).to_point()
-            }
-            TabIndicatorPosition::Right | TabIndicatorPosition::Bottom => Point::from((0., 0.)),
-        }
-    }
-
-    pub fn config(&self) -> niri_config::TabIndicator {
-        self.config
-    }
-}
-
-impl TabInfo {
-    pub fn from_tile<W: LayoutElement>(
-        tile: &Tile<W>,
-        position: Point<f64, Logical>,
-        is_active: bool,
-        config: &niri_config::TabIndicator,
-    ) -> Self {
-        let rules = tile.window().rules();
-        let rule = rules.tab_indicator;
-
-        let gradient_from_rule = || {
-            let (color, gradient) = if is_active {
-                (rule.active_color, rule.active_gradient)
-            } else {
-                (rule.inactive_color, rule.inactive_gradient)
-            };
-            let color = color.map(Gradient::from);
-            gradient.or(color)
-        };
-
-        let gradient_from_config = || {
-            let (color, gradient) = if is_active {
-                (config.active_color, config.active_gradient)
-            } else {
-                (config.inactive_color, config.inactive_gradient)
-            };
-            let color = color.map(Gradient::from);
-            gradient.or(color)
-        };
-
-        let gradient_from_border = || {
-            // Come up with tab indicator gradient matching the focus ring or the border, whichever
-            // one is enabled.
-            let focus_ring_config = tile.focus_ring().config();
-            let border_config = tile.border().config();
-            let config = if focus_ring_config.off {
-                border_config
-            } else {
-                focus_ring_config
-            };
-
-            let (color, gradient) = if is_active {
-                (config.active_color, config.active_gradient)
-            } else {
-                (config.inactive_color, config.inactive_gradient)
-            };
-            gradient.unwrap_or_else(|| Gradient::from(color))
-        };
-
-        let gradient = gradient_from_rule()
-            .or_else(gradient_from_config)
-            .unwrap_or_else(gradient_from_border);
-
-        let geometry = Rectangle::new(position, tile.animated_tile_size());
-
-        TabInfo { gradient, geometry }
-    }
-}

src/layout/tile.rs

@@ -1,5 +1,5 @@
-use core::f64;
 use std::rc::Rc;
+use std::time::Duration;
 
 use niri_config::{Color, CornerRadius, GradientInterpolation};
 use smithay::backend::allocator::Fourcc;
@@ -9,23 +9,20 @@ use smithay::utils::{Logical, Point, Rectangle, Scale, Size, Transform};
 
 use super::focus_ring::{FocusRing, FocusRingRenderElement};
 use super::opening_window::{OpenAnimation, OpeningWindowRenderElement};
-use super::shadow::Shadow;
 use super::{
-    HitType, LayoutElement, LayoutElementRenderElement, LayoutElementRenderSnapshot, Options,
+    LayoutElement, LayoutElementRenderElement, LayoutElementRenderSnapshot, Options,
-    SizeFrac, RESIZE_ANIMATION_THRESHOLD,
+    RESIZE_ANIMATION_THRESHOLD,
 };
-use crate::animation::{Animation, Clock};
+use crate::animation::Animation;
 use crate::niri_render_elements;
 use crate::render_helpers::border::BorderRenderElement;
 use crate::render_helpers::clipped_surface::{ClippedSurfaceRenderElement, RoundedCornerDamage};
 use crate::render_helpers::damage::ExtraDamage;
 use crate::render_helpers::renderer::NiriRenderer;
 use crate::render_helpers::resize::ResizeRenderElement;
-use crate::render_helpers::shadow::ShadowRenderElement;
 use crate::render_helpers::snapshot::RenderSnapshot;
 use crate::render_helpers::solid_color::{SolidColorBuffer, SolidColorRenderElement};
 use crate::render_helpers::{render_to_encompassing_texture, RenderTarget};
-use crate::utils::round_logical_in_physical;
 use crate::utils::transaction::Transaction;
 
 /// Toplevel window with decorations.
@@ -38,11 +35,11 @@ pub struct Tile<W: LayoutElement> {
     border: FocusRing,
 
     /// The focus ring around the window.
+    ///
+    /// It's supposed to be on the Workspace, but for the sake of a nicer open animation it's
+    /// currently here.
     focus_ring: FocusRing,
 
-    /// The shadow around the window.
-    shadow: Shadow,
-
     /// Whether this tile is fullscreen.
     ///
     /// This will update only when the `window` actually goes fullscreen, rather than right away,
@@ -52,27 +49,8 @@ pub struct Tile<W: LayoutElement> {
     /// The black backdrop for fullscreen windows.
     fullscreen_backdrop: SolidColorBuffer,
 
-    /// Whether the tile should float upon unfullscreening.
+    /// The size we were requested to fullscreen into.
-    pub(super) unfullscreen_to_floating: bool,
+    fullscreen_size: Size<f64, Logical>,
-
-    /// The size that the window should assume when going floating.
-    ///
-    /// This is generally the last size the window had when it was floating. It can be unknown if
-    /// the window starts out in the tiling layout or fullscreen.
-    pub(super) floating_window_size: Option<Size<i32, Logical>>,
-
-    /// The position that the tile should assume when going floating, relative to the floating
-    /// space working area.
-    ///
-    /// This is generally the last position the tile had when it was floating. It can be unknown if
-    /// the window starts out in the tiling layout.
-    pub(super) floating_pos: Option<Point<f64, SizeFrac>>,
-
-    /// Currently selected preset width index when this tile is floating.
-    pub(super) floating_preset_width_idx: Option<usize>,
-
-    /// Currently selected preset height index when this tile is floating.
-    pub(super) floating_preset_height_idx: Option<usize>,
 
     /// The animation upon opening a window.
     open_animation: Option<OpenAnimation>,
@@ -86,9 +64,6 @@ pub struct Tile<W: LayoutElement> {
     /// The animation of a tile visually moving vertically.
     move_y_animation: Option<MoveAnimation>,
 
-    /// The animation of the tile's opacity.
-    pub(super) alpha_animation: Option<Animation>,
-
     /// Offset during the initial interactive move rubberband.
     pub(super) interactive_move_offset: Point<f64, Logical>,
 
@@ -98,17 +73,9 @@ pub struct Tile<W: LayoutElement> {
     /// Extra damage for clipped surface corner radius changes.
     rounded_corner_damage: RoundedCornerDamage,
 
-    /// The view size for the tile's workspace.
-    ///
-    /// Used as the fullscreen target size.
-    view_size: Size<f64, Logical>,
-
     /// Scale of the output the tile is on (and rounds its sizes to).
     scale: f64,
 
-    /// Clock for driving animations.
-    pub(super) clock: Clock,
-
     /// Configurable properties of the layout.
     pub(super) options: Rc<Options>,
 }
@@ -121,7 +88,6 @@ niri_render_elements! {
         Opening = OpeningWindowRenderElement,
         Resize = ResizeRenderElement,
         Border = BorderRenderElement,
-        Shadow = ShadowRenderElement,
         ClippedSurface = ClippedSurfaceRenderElement<R>,
         ExtraDamage = ExtraDamage,
     }
@@ -144,61 +110,31 @@ struct MoveAnimation {
 }
 
 impl<W: LayoutElement> Tile<W> {
-    pub fn new(
+    pub fn new(window: W, scale: f64, options: Rc<Options>) -> Self {
-        window: W,
-        view_size: Size<f64, Logical>,
-        scale: f64,
-        clock: Clock,
-        options: Rc<Options>,
-    ) -> Self {
         let rules = window.rules();
         let border_config = rules.border.resolve_against(options.border);
         let focus_ring_config = rules.focus_ring.resolve_against(options.focus_ring.into());
-        let shadow_config = rules.shadow.resolve_against(options.shadow);
-        let is_fullscreen = window.is_fullscreen();
 
         Self {
             window,
             border: FocusRing::new(border_config.into()),
             focus_ring: FocusRing::new(focus_ring_config.into()),
-            shadow: Shadow::new(shadow_config),
+            is_fullscreen: false, // FIXME: up-to-date fullscreen right away, but we need size.
-            is_fullscreen,
+            fullscreen_backdrop: SolidColorBuffer::new((0., 0.), [0., 0., 0., 1.]),
-            fullscreen_backdrop: SolidColorBuffer::new(view_size, [0., 0., 0., 1.]),
+            fullscreen_size: Default::default(),
-            unfullscreen_to_floating: false,
-            floating_window_size: None,
-            floating_pos: None,
-            floating_preset_width_idx: None,
-            floating_preset_height_idx: None,
             open_animation: None,
             resize_animation: None,
             move_x_animation: None,
             move_y_animation: None,
-            alpha_animation: None,
             interactive_move_offset: Point::from((0., 0.)),
             unmap_snapshot: None,
             rounded_corner_damage: Default::default(),
-            view_size,
             scale,
-            clock,
             options,
         }
     }
 
-    pub fn update_config(
+    pub fn update_config(&mut self, scale: f64, options: Rc<Options>) {
-        &mut self,
-        view_size: Size<f64, Logical>,
-        scale: f64,
-        options: Rc<Options>,
-    ) {
-        // If preset widths or heights changed, clear our stored preset index.
-        if self.options.preset_column_widths != options.preset_column_widths {
-            self.floating_preset_width_idx = None;
-        }
-        if self.options.preset_window_heights != options.preset_window_heights {
-            self.floating_preset_height_idx = None;
-        }
-
-        self.view_size = view_size;
         self.scale = scale;
         self.options = options;
 
@@ -211,21 +147,18 @@ impl<W: LayoutElement> Tile<W> {
             .focus_ring
             .resolve_against(self.options.focus_ring.into());
         self.focus_ring.update_config(focus_ring_config.into());
-
-        let shadow_config = rules.shadow.resolve_against(self.options.shadow);
-        self.shadow.update_config(shadow_config);
-
-        self.fullscreen_backdrop.resize(view_size);
     }
 
     pub fn update_shaders(&mut self) {
         self.border.update_shaders();
         self.focus_ring.update_shaders();
-        self.shadow.update_shaders();
     }
 
     pub fn update_window(&mut self) {
+        // FIXME: remove when we can get a fullscreen size right away.
+        if self.fullscreen_size != Size::from((0., 0.)) {
             self.is_fullscreen = self.window.is_fullscreen();
+        }
 
         if let Some(animate_from) = self.window.take_animation_snapshot() {
             let size_from = if let Some(resize) = self.resize_animation.take() {
@@ -247,13 +180,7 @@ impl<W: LayoutElement> Tile<W> {
             let change = self.window.size().to_f64().to_point() - size_from.to_point();
             let change = f64::max(change.x.abs(), change.y.abs());
             if change > RESIZE_ANIMATION_THRESHOLD {
-                let anim = Animation::new(
+                let anim = Animation::new(0., 1., 0., self.options.animations.window_resize.anim);
-                    self.clock.clone(),
-                    0.,
-                    1.,
-                    0.,
-                    self.options.animations.window_resize.anim,
-                );
                 self.resize_animation = Some(ResizeAnimation {
                     anim,
                     size_from,
@@ -272,9 +199,6 @@ impl<W: LayoutElement> Tile<W> {
             .resolve_against(self.options.focus_ring.into());
         self.focus_ring.update_config(focus_ring_config.into());
 
-        let shadow_config = rules.shadow.resolve_against(self.options.shadow);
-        self.shadow.update_config(shadow_config);
-
         let window_size = self.window_size();
         let radius = rules
             .geometry_corner_radius
@@ -284,52 +208,44 @@ impl<W: LayoutElement> Tile<W> {
         self.rounded_corner_damage.set_size(window_size);
     }
 
-    pub fn advance_animations(&mut self) {
+    pub fn advance_animations(&mut self, current_time: Duration) {
         if let Some(open) = &mut self.open_animation {
+            open.advance_animations(current_time);
             if open.is_done() {
                 self.open_animation = None;
             }
         }
 
         if let Some(resize) = &mut self.resize_animation {
+            resize.anim.set_current_time(current_time);
             if resize.anim.is_done() {
                 self.resize_animation = None;
             }
         }
 
         if let Some(move_) = &mut self.move_x_animation {
+            move_.anim.set_current_time(current_time);
             if move_.anim.is_done() {
                 self.move_x_animation = None;
             }
         }
         if let Some(move_) = &mut self.move_y_animation {
+            move_.anim.set_current_time(current_time);
             if move_.anim.is_done() {
                 self.move_y_animation = None;
             }
         }
-
-        if let Some(alpha) = &mut self.alpha_animation {
-            if alpha.is_done() {
-                self.alpha_animation = None;
-            }
-        }
     }
 
     pub fn are_animations_ongoing(&self) -> bool {
-        self.are_transitions_ongoing() || self.window.rules().baba_is_float == Some(true)
-    }
-
-    pub fn are_transitions_ongoing(&self) -> bool {
         self.open_animation.is_some()
             || self.resize_animation.is_some()
             || self.move_x_animation.is_some()
             || self.move_y_animation.is_some()
-            || self.alpha_animation.is_some()
     }
 
-    pub fn update_render_elements(&mut self, is_active: bool, view_rect: Rectangle<f64, Logical>) {
+    pub fn update(&mut self, is_active: bool, view_rect: Rectangle<f64, Logical>) {
         let rules = self.window.rules();
-        let alpha = self.tile_alpha();
 
         let draw_border_with_background = rules
             .draw_border_with_background
@@ -348,28 +264,12 @@ impl<W: LayoutElement> Tile<W> {
             self.animated_window_size(),
             is_active,
             !draw_border_with_background,
-            Rectangle::new(
+            Rectangle::from_loc_and_size(
                 view_rect.loc - Point::from((border_width, border_width)),
                 view_rect.size,
             ),
             radius,
             self.scale,
-            alpha,
-        );
-
-        let radius = if self.is_fullscreen {
-            CornerRadius::default()
-        } else if self.effective_border_width().is_some() {
-            radius
-        } else {
-            rules.geometry_corner_radius.unwrap_or_default()
-        };
-        self.shadow.update_render_elements(
-            self.animated_tile_size(),
-            is_active,
-            radius,
-            self.scale,
-            alpha,
         );
 
         let draw_focus_ring_with_background = if self.effective_border_width().is_some() {
@@ -377,7 +277,14 @@ impl<W: LayoutElement> Tile<W> {
         } else {
             draw_border_with_background
         };
-        let radius = radius.expanded_by(self.focus_ring.width() as f32);
+        let radius = if self.is_fullscreen {
+            CornerRadius::default()
+        } else if self.effective_border_width().is_some() {
+            radius
+        } else {
+            rules.geometry_corner_radius.unwrap_or_default()
+        }
+        .expanded_by(self.focus_ring.width() as f32);
         self.focus_ring.update_render_elements(
             self.animated_tile_size(),
             is_active,
@@ -385,7 +292,6 @@ impl<W: LayoutElement> Tile<W> {
             view_rect,
             radius,
             self.scale,
-            alpha,
         );
     }
 
@@ -410,7 +316,6 @@ impl<W: LayoutElement> Tile<W> {
 
     pub fn start_open_animation(&mut self) {
         self.open_animation = Some(OpenAnimation::new(Animation::new(
-            self.clock.clone(),
             0.,
             1.,
             0.,
@@ -438,7 +343,7 @@ impl<W: LayoutElement> Tile<W> {
         let anim = self.move_x_animation.take().map(|move_| move_.anim);
         let anim = anim
             .map(|anim| anim.restarted(1., 0., 0.))
-            .unwrap_or_else(|| Animation::new(self.clock.clone(), 1., 0., 0., config));
+            .unwrap_or_else(|| Animation::new(1., 0., 0., config));
 
         self.move_x_animation = Some(MoveAnimation {
             anim,
@@ -457,7 +362,7 @@ impl<W: LayoutElement> Tile<W> {
         let anim = self.move_y_animation.take().map(|move_| move_.anim);
         let anim = anim
             .map(|anim| anim.restarted(1., 0., 0.))
-            .unwrap_or_else(|| Animation::new(self.clock.clone(), 1., 0., 0., config));
+            .unwrap_or_else(|| Animation::new(1., 0., 0., config));
 
         self.move_y_animation = Some(MoveAnimation {
             anim,
@@ -470,31 +375,6 @@ impl<W: LayoutElement> Tile<W> {
         self.move_y_animation = None;
     }
 
-    pub fn animate_alpha(&mut self, from: f64, to: f64, config: niri_config::Animation) {
-        let from = from.clamp(0., 1.);
-        let to = to.clamp(0., 1.);
-        let current = self.alpha_animation.take().map(|anim| anim.clamped_value());
-        let current = current.unwrap_or(from);
-        self.alpha_animation = Some(Animation::new(self.clock.clone(), current, to, 0., config));
-    }
-
-    pub fn ensure_alpha_animates_to_1(&mut self) {
-        if let Some(anim) = &self.alpha_animation {
-            if anim.to() != 1. {
-                // Cancel animation instead of starting a new one because the user likely wants to
-                // see the tile right away.
-                self.alpha_animation = None;
-            }
-        }
-    }
-
-    /// Opacity that applies to both window and decorations.
-    fn tile_alpha(&self) -> f32 {
-        self.alpha_animation
-            .as_ref()
-            .map_or(1., |anim| anim.clamped_value()) as f32
-    }
-
     pub fn window(&self) -> &W {
         &self.window
     }
@@ -503,6 +383,10 @@ impl<W: LayoutElement> Tile<W> {
         &mut self.window
     }
 
+    pub fn into_window(self) -> W {
+        self.window
+    }
+
     pub fn is_fullscreen(&self) -> bool {
         self.is_fullscreen
     }
@@ -527,7 +411,7 @@ impl<W: LayoutElement> Tile<W> {
         // In fullscreen, center the window in the given size.
         if self.is_fullscreen {
             let window_size = self.window_size();
-            let target_size = self.view_size;
+            let target_size = self.fullscreen_size;
 
             // Windows aren't supposed to be larger than the fullscreen size, but in case we get
             // one, leave it at the top-left as usual.
@@ -557,27 +441,8 @@ impl<W: LayoutElement> Tile<W> {
         if self.is_fullscreen {
             // Normally we'd just return the fullscreen size here, but this makes things a bit
             // nicer if a fullscreen window is bigger than the fullscreen size for some reason.
-            size.w = f64::max(size.w, self.view_size.w);
+            size.w = f64::max(size.w, self.fullscreen_size.w);
-            size.h = f64::max(size.h, self.view_size.h);
+            size.h = f64::max(size.h, self.fullscreen_size.h);
-            return size;
-        }
-
-        if let Some(width) = self.effective_border_width() {
-            size.w += width * 2.;
-            size.h += width * 2.;
-        }
-
-        size
-    }
-
-    pub fn tile_expected_or_current_size(&self) -> Size<f64, Logical> {
-        let mut size = self.window_expected_or_current_size();
-
-        if self.is_fullscreen {
-            // Normally we'd just return the fullscreen size here, but this makes things a bit
-            // nicer if a fullscreen window is bigger than the fullscreen size for some reason.
-            size.w = f64::max(size.w, self.view_size.w);
-            size.h = f64::max(size.h, self.view_size.h);
             return size;
         }
 
@@ -597,16 +462,7 @@ impl<W: LayoutElement> Tile<W> {
         size
     }
 
-    pub fn window_expected_or_current_size(&self) -> Size<f64, Logical> {
+    fn animated_window_size(&self) -> Size<f64, Logical> {
-        let size = self.window.expected_size();
-        let mut size = size.unwrap_or_else(|| self.window.size()).to_f64();
-        size = size
-            .to_physical_precise_round(self.scale)
-            .to_logical(self.scale);
-        size
-    }
-
-    pub fn animated_window_size(&self) -> Size<f64, Logical> {
         let mut size = self.window_size();
 
         if let Some(resize) = &self.resize_animation {
@@ -623,14 +479,14 @@ impl<W: LayoutElement> Tile<W> {
         size
     }
 
-    pub fn animated_tile_size(&self) -> Size<f64, Logical> {
+    fn animated_tile_size(&self) -> Size<f64, Logical> {
         let mut size = self.animated_window_size();
 
         if self.is_fullscreen {
             // Normally we'd just return the fullscreen size here, but this makes things a bit
             // nicer if a fullscreen window is bigger than the fullscreen size for some reason.
-            size.w = f64::max(size.w, self.view_size.w);
+            size.w = f64::max(size.w, self.fullscreen_size.w);
-            size.h = f64::max(size.h, self.view_size.h);
+            size.h = f64::max(size.h, self.fullscreen_size.h);
             return size;
         }
 
@@ -649,32 +505,16 @@ impl<W: LayoutElement> Tile<W> {
         loc
     }
 
-    fn is_in_input_region(&self, mut point: Point<f64, Logical>) -> bool {
+    pub fn is_in_input_region(&self, mut point: Point<f64, Logical>) -> bool {
         point -= self.window_loc().to_f64();
         self.window.is_in_input_region(point)
     }
 
-    fn is_in_activation_region(&self, point: Point<f64, Logical>) -> bool {
+    pub fn is_in_activation_region(&self, point: Point<f64, Logical>) -> bool {
-        let activation_region = Rectangle::from_size(self.tile_size());
+        let activation_region = Rectangle::from_loc_and_size((0., 0.), self.tile_size());
         activation_region.contains(point)
     }
 
-    pub fn hit(&self, point: Point<f64, Logical>) -> Option<HitType> {
-        let offset = self.bob_offset();
-        let point = point - offset;
-
-        if self.is_in_input_region(point) {
-            let win_pos = self.buf_loc() + offset;
-            Some(HitType::Input { win_pos })
-        } else if self.is_in_activation_region(point) {
-            Some(HitType::Activate {
-                is_tab_indicator: false,
-            })
-        } else {
-            None
-        }
-    }
-
     pub fn request_tile_size(
         &mut self,
         mut size: Size<f64, Logical>,
@@ -727,9 +567,10 @@ impl<W: LayoutElement> Tile<W> {
         }
     }
 
-    pub fn request_fullscreen(&mut self) {
+    pub fn request_fullscreen(&mut self, size: Size<f64, Logical>) {
-        self.window
+        self.fullscreen_backdrop.resize(size);
-            .request_fullscreen(self.view_size.to_i32_round());
+        self.fullscreen_size = size;
+        self.window.request_fullscreen(size.to_i32_round());
     }
 
     pub fn min_size(&self) -> Size<f64, Logical> {
@@ -761,18 +602,6 @@ impl<W: LayoutElement> Tile<W> {
         size
     }
 
-    pub fn bob_offset(&self) -> Point<f64, Logical> {
-        if self.window.rules().baba_is_float != Some(true) {
-            return Point::from((0., 0.));
-        }
-
-        let now = self.clock.now().as_secs_f64();
-        let amplitude = self.view_size.h / 96.;
-        let y = amplitude * ((f64::consts::TAU * now / 3.6).sin() - 1.);
-        let y = round_logical_in_physical(self.scale, y);
-        Point::from((0., y))
-    }
-
     pub fn draw_border_with_background(&self) -> bool {
         if self.effective_border_width().is_some() {
             return false;
@@ -784,40 +613,27 @@ impl<W: LayoutElement> Tile<W> {
             .unwrap_or_else(|| !self.window.has_ssd())
     }
 
-    fn render_inner<'a, R: NiriRenderer + 'a>(
+    fn render_inner<R: NiriRenderer>(
-        &'a self,
+        &self,
         renderer: &mut R,
         location: Point<f64, Logical>,
         scale: Scale<f64>,
         focus_ring: bool,
         target: RenderTarget,
-    ) -> impl Iterator<Item = TileRenderElement<R>> + 'a {
+    ) -> impl Iterator<Item = TileRenderElement<R>> {
         let _span = tracy_client::span!("Tile::render_inner");
 
-        let win_alpha = if self.is_fullscreen || self.window.is_ignoring_opacity_window_rule() {
+        let alpha = if self.is_fullscreen {
             1.
         } else {
             self.window.rules().opacity.unwrap_or(1.).clamp(0., 1.)
         };
 
-        let tile_alpha = self.tile_alpha();
-        let win_alpha = win_alpha * tile_alpha;
-
-        // This is here rather than in render_offset() because render_offset() is currently assumed
-        // by the code to be temporary. So, for example, interactive move will try to "grab" the
-        // tile at its current render offset and reset the render offset to zero by cancelling the
-        // tile move animations. On the other hand, bob_offset() is not resettable, so adding it in
-        // render_offset() would cause obvious animation glitches.
-        //
-        // This isn't to say that adding it here is perfect; indeed, it kind of breaks view_rect
-        // passed to update_render_elements(). But, it works well enough for what it is.
-        let location = location + self.bob_offset();
-
         let window_loc = self.window_loc();
         let window_size = self.window_size().to_f64();
         let animated_window_size = self.animated_window_size();
         let window_render_loc = location + window_loc;
-        let area = Rectangle::new(window_render_loc, animated_window_size);
+        let area = Rectangle::from_loc_and_size(window_render_loc, animated_window_size);
 
         let rules = self.window.rules();
         let clip_to_geometry = !self.is_fullscreen && rules.clip_to_geometry == Some(true);
@@ -831,7 +647,7 @@ impl<W: LayoutElement> Tile<W> {
         if let Some(resize) = &self.resize_animation {
             resize_popups = Some(
                 self.window
-                    .render_popups(renderer, window_render_loc, scale, win_alpha, target)
+                    .render_popups(renderer, window_render_loc, scale, alpha, target)
                     .into_iter()
                     .map(Into::into),
             );
@@ -881,7 +697,7 @@ impl<W: LayoutElement> Tile<W> {
                             resize.anim.clamped_value().clamp(0., 1.) as f32,
                             radius,
                             clip_to_geometry,
-                            win_alpha,
+                            alpha,
                         );
                         // FIXME: with split popups, this will use the resize element ID for
                         // popups, but we want the real IDs.
@@ -898,7 +714,7 @@ impl<W: LayoutElement> Tile<W> {
                     SolidColorRenderElement::from_buffer(
                         &fallback_buffer,
                         area.loc,
-                        win_alpha,
+                        alpha,
                         Kind::Unspecified,
                     )
                     .into(),
@@ -914,9 +730,9 @@ impl<W: LayoutElement> Tile<W> {
         if resize_shader.is_none() && resize_fallback.is_none() {
             let window = self
                 .window
-                .render(renderer, window_render_loc, scale, win_alpha, target);
+                .render(renderer, window_render_loc, scale, alpha, target);
 
-            let geo = Rectangle::new(window_render_loc, window_size);
+            let geo = Rectangle::from_loc_and_size(window_render_loc, window_size);
             let radius = radius.fit_to(window_size.w as f32, window_size.h as f32);
 
             let clip_shader = ClippedSurfaceRenderElement::shader(renderer).cloned();
@@ -958,16 +774,15 @@ impl<W: LayoutElement> Tile<W> {
                     if radius != CornerRadius::default() && has_border_shader {
                         return BorderRenderElement::new(
                             geo.size,
-                            Rectangle::from_size(geo.size),
+                            Rectangle::from_loc_and_size((0., 0.), geo.size),
                             GradientInterpolation::default(),
                             Color::from_color32f(elem.color()),
                             Color::from_color32f(elem.color()),
                             0.,
-                            Rectangle::from_size(geo.size),
+                            Rectangle::from_loc_and_size((0., 0.), geo.size),
                             0.,
                             radius,
                             scale.x as f32,
-                            1.,
                         )
                         .with_location(geo.loc)
                         .into();
@@ -994,7 +809,7 @@ impl<W: LayoutElement> Tile<W> {
             SolidColorRenderElement::from_buffer(
                 &self.fullscreen_backdrop,
                 location,
-                tile_alpha,
+                1.,
                 Kind::Unspecified,
             )
             .into()
@@ -1009,19 +824,17 @@ impl<W: LayoutElement> Tile<W> {
         let rv = rv.chain(elem.into_iter().flatten());
 
         let elem = focus_ring.then(|| self.focus_ring.render(renderer, location).map(Into::into));
-        let rv = rv.chain(elem.into_iter().flatten());
+        rv.chain(elem.into_iter().flatten())
-
-        rv.chain(self.shadow.render(renderer, location).map(Into::into))
     }
 
-    pub fn render<'a, R: NiriRenderer + 'a>(
+    pub fn render<R: NiriRenderer>(
-        &'a self,
+        &self,
         renderer: &mut R,
         location: Point<f64, Logical>,
         scale: Scale<f64>,
         focus_ring: bool,
         target: RenderTarget,
-    ) -> impl Iterator<Item = TileRenderElement<R>> + 'a {
+    ) -> impl Iterator<Item = TileRenderElement<R>> {
         let _span = tracy_client::span!("Tile::render");
 
         let mut open_anim_elem = None;
@@ -1103,35 +916,4 @@ impl<W: LayoutElement> Tile<W> {
     pub fn take_unmap_snapshot(&mut self) -> Option<TileRenderSnapshot> {
         self.unmap_snapshot.take()
     }
-
-    pub fn border(&self) -> &FocusRing {
-        &self.border
-    }
-
-    pub fn focus_ring(&self) -> &FocusRing {
-        &self.focus_ring
-    }
-
-    pub fn options(&self) -> &Rc<Options> {
-        &self.options
-    }
-
-    #[cfg(test)]
-    pub fn view_size(&self) -> Size<f64, Logical> {
-        self.view_size
-    }
-
-    #[cfg(test)]
-    pub fn verify_invariants(&self) {
-        use approx::assert_abs_diff_eq;
-
-        assert_eq!(self.is_fullscreen, self.window.is_fullscreen());
-        assert_eq!(self.fullscreen_backdrop.size(), self.view_size);
-
-        let scale = self.scale;
-        let size = self.tile_size();
-        let rounded = size.to_physical_precise_round(scale).to_logical(scale);
-        assert_abs_diff_eq!(size.w, rounded.w, epsilon = 1e-5);
-        assert_abs_diff_eq!(size.h, rounded.h, epsilon = 1e-5);
-    }
 }

src/lib.rs

@@ -11,7 +11,6 @@ pub mod frame_clock;
 pub mod handlers;
 pub mod input;
 pub mod ipc;
-pub mod layer;
 pub mod layout;
 pub mod niri;
 pub mod protocols;
@@ -28,6 +27,3 @@ pub mod pw_utils;
 
 #[cfg(not(feature = "xdp-gnome-screencast"))]
 pub use dummy_pw_utils as pw_utils;
-
-#[cfg(test)]
-mod tests;

src/main.rs

@@ -5,12 +5,13 @@ use std::fmt::Write as _;
 use std::fs::{self, File};
 use std::io::{self, Write};
 use std::os::fd::FromRawFd;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::process::Command;
 use std::{env, mem};
 
 use clap::Parser;
 use directories::ProjectDirs;
+use niri::animation;
 use niri::cli::{Cli, Sub};
 #[cfg(feature = "dbus")]
 use niri::dbus;
@@ -48,13 +49,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         REMOVE_ENV_RUST_LIB_BACKTRACE.store(true, Ordering::Relaxed);
     }
 
-    let directives = env::var("RUST_LOG").unwrap_or_else(|_| DEFAULT_LOG_FILTER.to_owned());
-    let env_filter = EnvFilter::builder().parse_lossy(directives);
-    tracing_subscriber::fmt()
-        .compact()
-        .with_env_filter(env_filter)
-        .init();
-
     if env::var_os("NOTIFY_SOCKET").is_some() {
         IS_SYSTEMD_SERVICE.store(true, Ordering::Relaxed);
 
@@ -65,12 +59,19 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         );
     }
 
+    let directives = env::var("RUST_LOG").unwrap_or_else(|_| DEFAULT_LOG_FILTER.to_owned());
+    let env_filter = EnvFilter::builder().parse_lossy(directives);
+    tracing_subscriber::fmt()
+        .compact()
+        .with_env_filter(env_filter)
+        .init();
+
     let cli = Cli::parse();
 
     if cli.session {
         // If we're starting as a session, assume that the intention is to start on a TTY. Remove
-        // DISPLAY, WAYLAND_DISPLAY or WAYLAND_SOCKET from our environment if they are set, since
+        // DISPLAY or WAYLAND_DISPLAY from our environment if they are set, since they will cause
-        // they will cause the winit backend to be selected instead.
+        // the winit backend to be selected instead.
         if env::var_os("DISPLAY").is_some() {
             warn!("running as a session but DISPLAY is set, removing it");
             env::remove_var("DISPLAY");
@@ -79,10 +80,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             warn!("running as a session but WAYLAND_DISPLAY is set, removing it");
             env::remove_var("WAYLAND_DISPLAY");
         }
-        if env::var_os("WAYLAND_SOCKET").is_some() {
-            warn!("running as a session but WAYLAND_SOCKET is set, removing it");
-            env::remove_var("WAYLAND_SOCKET");
-        }
 
         // Set the current desktop for xdg-desktop-portal.
         env::set_var("XDG_CURRENT_DESKTOP", "niri");
@@ -90,6 +87,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         env::set_var("XDG_SESSION_TYPE", "wayland");
     }
 
+    // Set a better error printer for config loading.
+    niri_config::set_miette_hook().unwrap();
+
     // Handle subcommands.
     if let Some(subcommand) = cli.subcommand {
         match subcommand {
@@ -164,6 +164,13 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         })
         .unwrap_or_default();
 
+    let slowdown = if config.animations.off {
+        0.
+    } else {
+        config.animations.slowdown.clamp(0., 100.)
+    };
+    animation::ANIMATION_SLOWDOWN.store(slowdown, Ordering::Relaxed);
+
     let spawn_at_startup = mem::take(&mut config.spawn_at_startup);
     *CHILD_ENV.write().unwrap() = mem::take(&mut config.environment);
 
@@ -177,13 +184,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         event_loop.handle(),
         event_loop.get_signal(),
         display,
-        false,
-        true,
     )
     .unwrap();
 
     // Set WAYLAND_DISPLAY for children.
-    let socket_name = state.niri.socket_name.as_deref().unwrap();
+    let socket_name = &state.niri.socket_name;
     env::set_var("WAYLAND_DISPLAY", socket_name);
     info!(
         "listening on Wayland socket: {}",
@@ -192,9 +197,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // Set NIRI_SOCKET for children.
     if let Some(ipc) = &state.niri.ipc_server {
-        let socket_path = ipc.socket_path.as_deref().unwrap();
+        env::set_var(SOCKET_PATH_ENV, &ipc.socket_path);
-        env::set_var(SOCKET_PATH_ENV, socket_path);
+        info!("IPC listening on: {}", ipc.socket_path.to_string_lossy());
-        info!("IPC listening on: {}", socket_path.to_string_lossy());
     }
 
     if cli.session {
@@ -227,20 +231,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // Set up config file watcher.
     let _watcher = {
-        // Parsing the config actually takes > 20 ms on my beefy machine, so let's do it on the
-        // watcher thread.
-        let process = |path: &Path| {
-            Config::load(path).map_err(|err| {
-                warn!("{:?}", err.context("error loading config"));
-            })
-        };
-
         let (tx, rx) = calloop::channel::sync_channel(1);
-        let watcher = Watcher::new(watch_path.clone(), process, tx);
+        let watcher = Watcher::new(watch_path.clone(), tx);
         event_loop
             .handle()
-            .insert_source(rx, |event, _, state| match event {
+            .insert_source(rx, move |event, _, state| match event {
-                calloop::channel::Event::Msg(config) => state.reload_config(config),
+                calloop::channel::Event::Msg(()) => state.reload_config(watch_path.clone()),
                 calloop::channel::Event::Closed => (),
             })
             .unwrap();
@@ -248,10 +244,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     };
 
     // Spawn commands from cli and auto-start.
-    spawn(cli.command, None);
+    spawn(cli.command);
 
     for elem in spawn_at_startup {
-        spawn(elem.command, None);
+        spawn(elem.command);
     }
 
     // Show the config error notification right away if needed.

src/protocols/gamma_control.rs

@@ -177,6 +177,7 @@ where
                     }
 
                     // Verify that there's no more data.
+                    #[allow(clippy::unused_io_amount)] // False positive on 1.77.0
                     {
                         match file.read(&mut [0]) {
                             Ok(0) => (),

src/protocols/mod.rs

@@ -3,6 +3,5 @@ pub mod gamma_control;
 pub mod mutter_x11_interop;
 pub mod output_management;
 pub mod screencopy;
-pub mod virtual_pointer;
 
 pub mod raw;

src/protocols/screencopy.rs

@@ -206,9 +206,9 @@ where
                 let output_transform = output.current_transform();
                 let output_physical_size =
                     output_transform.transform_size(output.current_mode().unwrap().size);
-                let output_rect = Rectangle::from_size(output_physical_size);
+                let output_rect = Rectangle::from_loc_and_size((0, 0), output_physical_size);
 
-                let rect = Rectangle::new(Point::from((x, y)), Size::from((width, height)));
+                let rect = Rectangle::from_loc_and_size((x, y), (width, height));
 
                 let output_scale = output.current_scale().fractional_scale();
                 let physical_rect = rect.to_physical_precise_round(output_scale);

src/protocols/virtual_pointer.rs

@@ -1,563 +0,0 @@
-use std::collections::HashSet;
-use std::sync::Mutex;
-
-use smithay::backend::input::{
-    AbsolutePositionEvent, Axis, AxisRelativeDirection, AxisSource, ButtonState, Device,
-    DeviceCapability, Event, InputBackend, PointerAxisEvent, PointerButtonEvent,
-    PointerMotionAbsoluteEvent, PointerMotionEvent, UnusedEvent,
-};
-use smithay::input::pointer::AxisFrame;
-use smithay::output::Output;
-use smithay::reexports::wayland_protocols_wlr;
-use smithay::reexports::wayland_server::protocol::wl_pointer;
-use smithay::reexports::wayland_server::protocol::wl_seat::WlSeat;
-use smithay::reexports::wayland_server::{
-    Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource,
-};
-use wayland_backend::protocol::WEnum;
-use wayland_protocols_wlr::virtual_pointer::v1::server::{
-    zwlr_virtual_pointer_manager_v1, zwlr_virtual_pointer_v1,
-};
-use zwlr_virtual_pointer_manager_v1::ZwlrVirtualPointerManagerV1;
-use zwlr_virtual_pointer_v1::ZwlrVirtualPointerV1;
-
-const VERSION: u32 = 2;
-
-pub struct VirtualPointerManagerState {
-    virtual_pointers: HashSet<ZwlrVirtualPointerV1>,
-}
-
-pub struct VirtualPointerManagerGlobalData {
-    filter: Box<dyn for<'c> Fn(&'c Client) -> bool + Send + Sync>,
-}
-
-pub struct VirtualPointerInputBackend;
-
-#[derive(Clone, Debug, Hash, Eq, PartialEq)]
-pub struct VirtualPointer {
-    pointer: ZwlrVirtualPointerV1,
-}
-
-#[derive(Debug)]
-pub struct VirtualPointerUserData {
-    seat: Option<WlSeat>,
-    output: Option<Output>,
-
-    axis_frame: Mutex<Option<AxisFrame>>,
-}
-
-impl VirtualPointer {
-    fn data(&self) -> &VirtualPointerUserData {
-        self.pointer.data().unwrap()
-    }
-
-    pub fn seat(&self) -> Option<&WlSeat> {
-        self.data().seat.as_ref()
-    }
-
-    pub fn output(&self) -> Option<&Output> {
-        self.data().output.as_ref()
-    }
-
-    fn finish_axis_frame(&self) -> Option<AxisFrame> {
-        self.data().axis_frame.lock().unwrap().take()
-    }
-
-    fn mutate_axis_frame(&self, time: Option<u32>, f: impl FnOnce(AxisFrame) -> AxisFrame) {
-        let mut frame = self.data().axis_frame.lock().unwrap();
-
-        *frame = frame.or(time.map(AxisFrame::new)).map(f);
-    }
-}
-
-impl Device for VirtualPointer {
-    fn id(&self) -> String {
-        format!("wlr virtual pointer {}", self.pointer.id())
-    }
-
-    fn name(&self) -> String {
-        String::from("virtual pointer")
-    }
-
-    fn has_capability(&self, capability: DeviceCapability) -> bool {
-        matches!(capability, DeviceCapability::Pointer)
-    }
-
-    fn usb_id(&self) -> Option<(u32, u32)> {
-        None
-    }
-
-    fn syspath(&self) -> Option<std::path::PathBuf> {
-        None
-    }
-}
-
-pub struct VirtualPointerMotionEvent {
-    pointer: VirtualPointer,
-    time: u32,
-    dx: f64,
-    dy: f64,
-}
-
-impl Event<VirtualPointerInputBackend> for VirtualPointerMotionEvent {
-    fn time(&self) -> u64 {
-        self.time as u64 * 1000 // millis to micros
-    }
-
-    fn device(&self) -> VirtualPointer {
-        self.pointer.clone()
-    }
-}
-
-impl PointerMotionEvent<VirtualPointerInputBackend> for VirtualPointerMotionEvent {
-    fn delta_x(&self) -> f64 {
-        self.dx
-    }
-
-    fn delta_y(&self) -> f64 {
-        self.dy
-    }
-
-    fn delta_x_unaccel(&self) -> f64 {
-        self.dx
-    }
-
-    fn delta_y_unaccel(&self) -> f64 {
-        self.dy
-    }
-}
-
-pub struct VirtualPointerMotionAbsoluteEvent {
-    pointer: VirtualPointer,
-    time: u32,
-    x: u32,
-    y: u32,
-    x_extent: u32,
-    y_extent: u32,
-}
-
-impl Event<VirtualPointerInputBackend> for VirtualPointerMotionAbsoluteEvent {
-    fn time(&self) -> u64 {
-        self.time as u64 * 1000 // millis to micros
-    }
-
-    fn device(&self) -> VirtualPointer {
-        self.pointer.clone()
-    }
-}
-
-impl AbsolutePositionEvent<VirtualPointerInputBackend> for VirtualPointerMotionAbsoluteEvent {
-    fn x(&self) -> f64 {
-        self.x as f64 / self.x_extent as f64
-    }
-
-    fn y(&self) -> f64 {
-        self.y as f64 / self.y_extent as f64
-    }
-
-    fn x_transformed(&self, width: i32) -> f64 {
-        (self.x as i64 * width as i64) as f64 / self.x_extent as f64
-    }
-
-    fn y_transformed(&self, height: i32) -> f64 {
-        (self.y as i64 * height as i64) as f64 / self.y_extent as f64
-    }
-}
-
-pub struct VirtualPointerButtonEvent {
-    pointer: VirtualPointer,
-    time: u32,
-    button: u32,
-    state: ButtonState,
-}
-
-impl Event<VirtualPointerInputBackend> for VirtualPointerButtonEvent {
-    fn time(&self) -> u64 {
-        self.time as u64 * 1000 // millis to micros
-    }
-
-    fn device(&self) -> VirtualPointer {
-        self.pointer.clone()
-    }
-}
-
-impl PointerButtonEvent<VirtualPointerInputBackend> for VirtualPointerButtonEvent {
-    fn button_code(&self) -> u32 {
-        self.button
-    }
-
-    fn state(&self) -> ButtonState {
-        self.state
-    }
-}
-
-pub struct VirtualPointerAxisEvent {
-    pointer: VirtualPointer,
-    frame: AxisFrame,
-}
-
-impl Event<VirtualPointerInputBackend> for VirtualPointerAxisEvent {
-    fn time(&self) -> u64 {
-        self.frame.time as u64 * 1000 // millis to micros
-    }
-
-    fn device(&self) -> VirtualPointer {
-        self.pointer.clone()
-    }
-}
-
-fn tuple_axis<T>(tuple: (T, T), axis: Axis) -> T {
-    match axis {
-        Axis::Horizontal => tuple.0,
-        Axis::Vertical => tuple.1,
-    }
-}
-
-impl PointerAxisEvent<VirtualPointerInputBackend> for VirtualPointerAxisEvent {
-    fn amount(&self, axis: Axis) -> Option<f64> {
-        Some(tuple_axis(self.frame.axis, axis))
-    }
-
-    fn amount_v120(&self, axis: Axis) -> Option<f64> {
-        self.frame.v120.map(|v120| tuple_axis(v120, axis) as f64)
-    }
-
-    fn source(&self) -> AxisSource {
-        self.frame.source.unwrap_or_else(|| {
-            warn!("AxisSource: no source set, giving bogus value");
-            AxisSource::Continuous
-        })
-    }
-
-    fn relative_direction(&self, axis: Axis) -> AxisRelativeDirection {
-        tuple_axis(self.frame.relative_direction, axis)
-    }
-}
-
-impl PointerMotionAbsoluteEvent<VirtualPointerInputBackend> for VirtualPointerMotionAbsoluteEvent {}
-
-impl InputBackend for VirtualPointerInputBackend {
-    type Device = VirtualPointer;
-
-    type KeyboardKeyEvent = UnusedEvent;
-    type PointerAxisEvent = VirtualPointerAxisEvent;
-    type PointerButtonEvent = VirtualPointerButtonEvent;
-    type PointerMotionEvent = VirtualPointerMotionEvent;
-    type PointerMotionAbsoluteEvent = VirtualPointerMotionAbsoluteEvent;
-
-    type GestureSwipeBeginEvent = UnusedEvent;
-    type GestureSwipeUpdateEvent = UnusedEvent;
-    type GestureSwipeEndEvent = UnusedEvent;
-    type GesturePinchBeginEvent = UnusedEvent;
-    type GesturePinchUpdateEvent = UnusedEvent;
-    type GesturePinchEndEvent = UnusedEvent;
-    type GestureHoldBeginEvent = UnusedEvent;
-    type GestureHoldEndEvent = UnusedEvent;
-
-    type TouchDownEvent = UnusedEvent;
-    type TouchUpEvent = UnusedEvent;
-    type TouchMotionEvent = UnusedEvent;
-    type TouchCancelEvent = UnusedEvent;
-    type TouchFrameEvent = UnusedEvent;
-    type TabletToolAxisEvent = UnusedEvent;
-    type TabletToolProximityEvent = UnusedEvent;
-    type TabletToolTipEvent = UnusedEvent;
-    type TabletToolButtonEvent = UnusedEvent;
-
-    type SwitchToggleEvent = UnusedEvent;
-
-    type SpecialEvent = UnusedEvent;
-}
-
-pub trait VirtualPointerHandler {
-    fn virtual_pointer_manager_state(&mut self) -> &mut VirtualPointerManagerState;
-
-    fn create_virtual_pointer(&mut self, pointer: VirtualPointer) {
-        let _ = pointer;
-    }
-    fn destroy_virtual_pointer(&mut self, pointer: VirtualPointer) {
-        let _ = pointer;
-    }
-
-    fn on_virtual_pointer_motion(&mut self, event: VirtualPointerMotionEvent);
-    fn on_virtual_pointer_motion_absolute(&mut self, event: VirtualPointerMotionAbsoluteEvent);
-    fn on_virtual_pointer_button(&mut self, event: VirtualPointerButtonEvent);
-    fn on_virtual_pointer_axis(&mut self, event: VirtualPointerAxisEvent);
-}
-
-impl VirtualPointerManagerState {
-    pub fn new<D, F>(display: &DisplayHandle, filter: F) -> Self
-    where
-        D: GlobalDispatch<ZwlrVirtualPointerManagerV1, VirtualPointerManagerGlobalData>,
-        D: Dispatch<ZwlrVirtualPointerManagerV1, ()>,
-        D: Dispatch<ZwlrVirtualPointerV1, VirtualPointerUserData>,
-        D: VirtualPointerHandler,
-        D: 'static,
-        F: for<'c> Fn(&'c Client) -> bool + Send + Sync + 'static,
-    {
-        let global_data = VirtualPointerManagerGlobalData {
-            filter: Box::new(filter),
-        };
-        display.create_global::<D, ZwlrVirtualPointerManagerV1, _>(VERSION, global_data);
-
-        Self {
-            virtual_pointers: HashSet::new(),
-        }
-    }
-}
-
-impl<D> GlobalDispatch<ZwlrVirtualPointerManagerV1, VirtualPointerManagerGlobalData, D>
-    for VirtualPointerManagerState
-where
-    D: GlobalDispatch<ZwlrVirtualPointerManagerV1, VirtualPointerManagerGlobalData>,
-    D: Dispatch<ZwlrVirtualPointerManagerV1, ()>,
-    D: Dispatch<ZwlrVirtualPointerV1, VirtualPointerUserData>,
-    D: VirtualPointerHandler,
-    D: 'static,
-{
-    fn bind(
-        _state: &mut D,
-        _handle: &DisplayHandle,
-        _client: &Client,
-        manager: New<ZwlrVirtualPointerManagerV1>,
-        _manager_state: &VirtualPointerManagerGlobalData,
-        data_init: &mut DataInit<'_, D>,
-    ) {
-        data_init.init(manager, ());
-    }
-
-    fn can_view(client: Client, global_data: &VirtualPointerManagerGlobalData) -> bool {
-        (global_data.filter)(&client)
-    }
-}
-
-impl<D> Dispatch<ZwlrVirtualPointerManagerV1, (), D> for VirtualPointerManagerState
-where
-    D: Dispatch<ZwlrVirtualPointerManagerV1, ()>,
-    D: Dispatch<ZwlrVirtualPointerV1, VirtualPointerUserData>,
-    D: VirtualPointerHandler,
-    D: 'static,
-{
-    fn request(
-        state: &mut D,
-        _client: &Client,
-        _resource: &ZwlrVirtualPointerManagerV1,
-        request: <ZwlrVirtualPointerManagerV1 as Resource>::Request,
-        _data: &(),
-        _dhandle: &DisplayHandle,
-        data_init: &mut DataInit<'_, D>,
-    ) {
-        let (id, seat, output) = match request {
-            zwlr_virtual_pointer_manager_v1::Request::CreateVirtualPointer { seat, id } => {
-                (id, seat, None)
-            }
-            zwlr_virtual_pointer_manager_v1::Request::CreateVirtualPointerWithOutput {
-                seat,
-                output,
-                id,
-            } => (id, seat, output.as_ref().and_then(Output::from_resource)),
-            zwlr_virtual_pointer_manager_v1::Request::Destroy => return,
-            _ => unreachable!(),
-        };
-
-        let pointer = data_init.init(
-            id,
-            VirtualPointerUserData {
-                seat,
-                output,
-                axis_frame: Mutex::new(None),
-            },
-        );
-        state
-            .virtual_pointer_manager_state()
-            .virtual_pointers
-            .insert(pointer.clone());
-
-        state.create_virtual_pointer(VirtualPointer { pointer });
-    }
-}
-
-impl<D> Dispatch<ZwlrVirtualPointerV1, VirtualPointerUserData, D> for VirtualPointerManagerState
-where
-    D: Dispatch<ZwlrVirtualPointerV1, VirtualPointerUserData>,
-    D: VirtualPointerHandler,
-    D: 'static,
-{
-    fn request(
-        handler: &mut D,
-        _client: &Client,
-        resource: &ZwlrVirtualPointerV1,
-        request: <ZwlrVirtualPointerV1 as Resource>::Request,
-        _data: &VirtualPointerUserData,
-        _dhandle: &DisplayHandle,
-        _data_init: &mut DataInit<'_, D>,
-    ) {
-        let pointer = VirtualPointer {
-            pointer: resource.clone(),
-        };
-        match request {
-            zwlr_virtual_pointer_v1::Request::Motion { time, dx, dy } => {
-                let event = VirtualPointerMotionEvent {
-                    pointer,
-                    time,
-                    dx,
-                    dy,
-                };
-                handler.on_virtual_pointer_motion(event);
-            }
-            zwlr_virtual_pointer_v1::Request::MotionAbsolute {
-                time,
-                x,
-                y,
-                x_extent,
-                y_extent,
-            } => {
-                let event = VirtualPointerMotionAbsoluteEvent {
-                    pointer,
-                    time,
-                    x,
-                    y,
-                    x_extent,
-                    y_extent,
-                };
-                handler.on_virtual_pointer_motion_absolute(event);
-            }
-            zwlr_virtual_pointer_v1::Request::Button {
-                time,
-                button,
-                state,
-            } => {
-                // state is an enum but wlroots treats it as a C boolean (zero or nonzero)
-                // so we emulate that behaviour too. ButtonState::Pressed and any invalid value
-                // counts as pressed.
-                // https://gitlab.freedesktop.org/wlroots/wlroots/-/blob/3187479c07c34a4de82c06a316a763a36a0499da/types/wlr_virtual_pointer_v1.c#L74
-                let state = match state {
-                    WEnum::Value(wl_pointer::ButtonState::Released) => ButtonState::Released,
-                    _ => ButtonState::Pressed,
-                };
-                let event = VirtualPointerButtonEvent {
-                    pointer,
-                    time,
-                    button,
-                    state,
-                };
-                handler.on_virtual_pointer_button(event);
-            }
-            zwlr_virtual_pointer_v1::Request::Axis { time, axis, value } => {
-                let axis = match axis {
-                    WEnum::Value(wl_pointer::Axis::VerticalScroll) => Axis::Vertical,
-                    WEnum::Value(wl_pointer::Axis::HorizontalScroll) => Axis::Horizontal,
-                    _ => {
-                        warn!("Axis: invalid axis");
-                        resource.post_error(
-                            zwlr_virtual_pointer_v1::Error::InvalidAxis,
-                            "invalid axis",
-                        );
-                        return;
-                    }
-                };
-
-                pointer.mutate_axis_frame(Some(time), |frame| frame.value(axis, value));
-            }
-            zwlr_virtual_pointer_v1::Request::Frame => {
-                if let Some(frame) = pointer.finish_axis_frame() {
-                    let event = VirtualPointerAxisEvent { pointer, frame };
-                    handler.on_virtual_pointer_axis(event);
-                }
-            }
-            zwlr_virtual_pointer_v1::Request::AxisSource { axis_source } => {
-                let axis_source = match axis_source {
-                    WEnum::Value(wl_pointer::AxisSource::Wheel) => AxisSource::Wheel,
-                    WEnum::Value(wl_pointer::AxisSource::Finger) => AxisSource::Finger,
-                    WEnum::Value(wl_pointer::AxisSource::Continuous) => AxisSource::Continuous,
-                    WEnum::Value(wl_pointer::AxisSource::WheelTilt) => AxisSource::WheelTilt,
-
-                    _ => {
-                        warn!("AxisSource: invalid axis source");
-                        resource.post_error(
-                            zwlr_virtual_pointer_v1::Error::InvalidAxisSource,
-                            "invalid axis source",
-                        );
-                        return;
-                    }
-                };
-
-                pointer.mutate_axis_frame(None, |frame| frame.source(axis_source));
-            }
-            zwlr_virtual_pointer_v1::Request::AxisStop { time, axis } => {
-                let axis = match axis {
-                    WEnum::Value(wl_pointer::Axis::VerticalScroll) => Axis::Vertical,
-                    WEnum::Value(wl_pointer::Axis::HorizontalScroll) => Axis::Horizontal,
-                    _ => {
-                        warn!("AxisStop: invalid axis");
-                        resource.post_error(
-                            zwlr_virtual_pointer_v1::Error::InvalidAxis,
-                            "invalid axis",
-                        );
-                        return;
-                    }
-                };
-
-                pointer.mutate_axis_frame(Some(time), |frame| frame.stop(axis));
-            }
-            zwlr_virtual_pointer_v1::Request::AxisDiscrete {
-                time,
-                axis,
-                value,
-                discrete,
-            } => {
-                let axis = match axis {
-                    WEnum::Value(wl_pointer::Axis::VerticalScroll) => Axis::Vertical,
-                    WEnum::Value(wl_pointer::Axis::HorizontalScroll) => Axis::Horizontal,
-                    _ => {
-                        warn!("AxisDiscrete: invalid axis");
-                        resource.post_error(
-                            zwlr_virtual_pointer_v1::Error::InvalidAxis,
-                            "invalid axis",
-                        );
-                        return;
-                    }
-                };
-                pointer.mutate_axis_frame(Some(time), |frame| {
-                    frame.value(axis, value).v120(axis, discrete)
-                });
-            }
-            zwlr_virtual_pointer_v1::Request::Destroy => {}
-            _ => unreachable!(),
-        }
-    }
-
-    fn destroyed(
-        handler: &mut D,
-        _client: wayland_backend::server::ClientId,
-        resource: &ZwlrVirtualPointerV1,
-        _data: &VirtualPointerUserData,
-    ) {
-        let pointer = VirtualPointer {
-            pointer: resource.clone(),
-        };
-
-        handler.destroy_virtual_pointer(pointer);
-        handler
-            .virtual_pointer_manager_state()
-            .virtual_pointers
-            .remove(resource);
-    }
-}
-
-#[macro_export]
-macro_rules! delegate_virtual_pointer {
-    ($(@<$( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+>)? $ty: ty) => {
-        smithay::reexports::wayland_server::delegate_global_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            smithay::reexports::wayland_protocols_wlr::virtual_pointer::v1::server::zwlr_virtual_pointer_manager_v1::ZwlrVirtualPointerManagerV1: $crate::protocols::virtual_pointer::VirtualPointerManagerGlobalData
-            ] => $crate::protocols::virtual_pointer::VirtualPointerManagerState);
-
-        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            smithay::reexports::wayland_protocols_wlr::virtual_pointer::v1::server::zwlr_virtual_pointer_manager_v1::ZwlrVirtualPointerManagerV1: ()
-        ] => $crate::protocols::virtual_pointer::VirtualPointerManagerState);
-
-        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            smithay::reexports::wayland_protocols_wlr::virtual_pointer::v1::server::zwlr_virtual_pointer_v1::ZwlrVirtualPointerV1:  $crate::protocols::virtual_pointer::VirtualPointerUserData
-        ] => $crate::protocols::virtual_pointer::VirtualPointerManagerState);
-    };
-}

src/pw_utils.rs

@@ -11,7 +11,7 @@ use anyhow::Context as _;
 use calloop::timer::{TimeoutAction, Timer};
 use calloop::RegistrationToken;
 use pipewire::context::Context;
-use pipewire::core::{Core, PW_ID_CORE};
+use pipewire::core::Core;
 use pipewire::main_loop::MainLoop;
 use pipewire::properties::Properties;
 use pipewire::spa::buffer::DataType;
@@ -41,7 +41,7 @@ use smithay::reexports::calloop::generic::Generic;
 use smithay::reexports::calloop::{Interest, LoopHandle, Mode, PostAction};
 use smithay::reexports::gbm::Modifier;
 use smithay::utils::{Physical, Scale, Size, Transform};
-use zbus::object_server::SignalEmitter;
+use zbus::SignalContext;
 
 use crate::dbus::mutter_screen_cast::{self, CursorMode};
 use crate::niri::State;
@@ -54,14 +54,12 @@ const CAST_DELAY_ALLOWANCE: Duration = Duration::from_micros(100);
 pub struct PipeWire {
     _context: Context,
     pub core: Core,
-    pub token: RegistrationToken,
     to_niri: calloop::channel::Sender<PwToNiri>,
 }
 
 pub enum PwToNiri {
     StopCast { session_id: usize },
     Redraw(CastTarget),
-    FatalError,
 }
 
 pub struct Cast {
@@ -136,26 +134,15 @@ macro_rules! make_params {
 }
 
 impl PipeWire {
-    pub fn new(
+    pub fn new(event_loop: &LoopHandle<'static, State>) -> anyhow::Result<Self> {
-        event_loop: &LoopHandle<'static, State>,
-        to_niri: calloop::channel::Sender<PwToNiri>,
-    ) -> anyhow::Result<Self> {
         let main_loop = MainLoop::new(None).context("error creating MainLoop")?;
         let context = Context::new(&main_loop).context("error creating Context")?;
         let core = context.connect(None).context("error creating Core")?;
 
-        let to_niri_ = to_niri.clone();
         let listener = core
             .add_listener_local()
-            .error(move |id, seq, res, message| {
+            .error(|id, seq, res, message| {
                 warn!(id, seq, res, message, "pw error");
-
-                // Reset PipeWire on connection errors.
-                if id == PW_ID_CORE && res == -32 {
-                    if let Err(err) = to_niri_.send(PwToNiri::FatalError) {
-                        warn!("error sending FatalError to niri: {err:?}");
-                    }
-                }
             })
             .register();
         mem::forget(listener);
@@ -167,7 +154,7 @@ impl PipeWire {
             }
         }
         let generic = Generic::new(AsFdWrapper(main_loop), Interest::READ, Mode::Level);
-        let token = event_loop
+        event_loop
             .insert_source(generic, move |_, wrapper, _| {
                 let _span = tracy_client::span!("pipewire iteration");
                 wrapper.0.loop_().iterate(Duration::ZERO);
@@ -175,10 +162,17 @@ impl PipeWire {
             })
             .unwrap();
 
+        let (to_niri, from_pipewire) = calloop::channel::channel();
+        event_loop
+            .insert_source(from_pipewire, move |event, _, state| match event {
+                calloop::channel::Event::Msg(msg) => state.on_pw_msg(msg),
+                calloop::channel::Event::Closed => (),
+            })
+            .unwrap();
+
         Ok(Self {
             _context: context,
             core,
-            token,
             to_niri,
         })
     }
@@ -194,7 +188,7 @@ impl PipeWire {
         refresh: u32,
         alpha: bool,
         cursor_mode: CursorMode,
-        signal_ctx: SignalEmitter<'static>,
+        signal_ctx: SignalContext<'static>,
     ) -> anyhow::Result<Cast> {
         let _span = tracy_client::span!("PipeWire::start_cast");
 
@@ -775,11 +769,7 @@ impl Cast {
         let timer = Timer::from_duration(duration);
         let token = event_loop
             .insert_source(timer, move |_, _, state| {
-                // Guard against output disconnecting before the timer has a chance to run.
-                if state.niri.output_state.contains_key(&output) {
                 state.niri.queue_redraw(&output);
-                }
-
                 TimeoutAction::Drop
             })
             .unwrap();
@@ -844,9 +834,12 @@ impl Cast {
             return false;
         }
 
-        let Some(mut buffer) = self.stream.dequeue_buffer() else {
+        let mut buffer = match self.stream.dequeue_buffer() {
+            Some(buffer) => buffer,
+            None => {
                 warn!("no available buffer in pw stream, skipping frame");
                 return false;
+            }
         };
 
         let fd = buffer.datas_mut()[0].as_raw().fd;
@@ -1030,7 +1023,7 @@ fn allocate_buffer(
             .create_buffer_object_with_modifiers2::<()>(w, h, fourcc, modifiers, flags)
             .context("error creating GBM buffer object")?;
 
-        let modifier = bo.modifier();
+        let modifier = bo.modifier().unwrap();
         let buffer = GbmBuffer::from_bo(bo, false);
         Ok((buffer, modifier))
     }

src/render_helpers/border.rs

@@ -39,7 +39,6 @@ struct Parameters {
     corner_radius: CornerRadius,
     // Should only be used for visual improvements, i.e. corner radius anti-aliasing.
     scale: f32,
-    alpha: f32,
 }
 
 impl BorderRenderElement {
@@ -55,7 +54,6 @@ impl BorderRenderElement {
         border_width: f32,
         corner_radius: CornerRadius,
         scale: f32,
-        alpha: f32,
     ) -> Self {
         let inner = ShaderRenderElement::empty(ProgramType::Border, Kind::Unspecified);
         let mut rv = Self {
@@ -71,7 +69,6 @@ impl BorderRenderElement {
                 border_width,
                 corner_radius,
                 scale,
-                alpha,
             },
         };
         rv.update_inner();
@@ -93,7 +90,6 @@ impl BorderRenderElement {
                 border_width: 0.,
                 corner_radius: Default::default(),
                 scale: 1.,
-                alpha: 1.,
             },
         }
     }
@@ -115,7 +111,6 @@ impl BorderRenderElement {
         border_width: f32,
         corner_radius: CornerRadius,
         scale: f32,
-        alpha: f32,
     ) {
         let params = Parameters {
             size,
@@ -128,7 +123,6 @@ impl BorderRenderElement {
             border_width,
             corner_radius,
             scale,
-            alpha,
         };
         if self.params == params {
             return;
@@ -150,7 +144,6 @@ impl BorderRenderElement {
             border_width,
             corner_radius,
             scale,
-            alpha,
         } = self.params;
 
         let grad_offset = geometry.loc - gradient_area.loc;
@@ -196,7 +189,6 @@ impl BorderRenderElement {
             size,
             None,
             scale,
-            alpha,
             vec![
                 Uniform::new("colorspace", colorspace),
                 Uniform::new("hue_interpolation", hue_interpolation),

src/render_helpers/clipped_surface.rs

@@ -6,7 +6,7 @@ use smithay::backend::renderer::gles::{
     GlesError, GlesFrame, GlesRenderer, GlesTexProgram, Uniform,
 };
 use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
-use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform};
+use smithay::utils::{Buffer, Logical, Physical, Rectangle, Scale, Size, Transform};
 
 use super::damage::ExtraDamage;
 use super::renderer::{AsGlesFrame as _, NiriRenderer};
@@ -19,7 +19,9 @@ pub struct ClippedSurfaceRenderElement<R: NiriRenderer> {
     program: GlesTexProgram,
     corner_radius: CornerRadius,
     geometry: Rectangle<f64, Logical>,
-    uniforms: Vec<Uniform<'static>>,
+    input_to_geo: Mat3,
+    // Should only be used for visual improvements, i.e. corner radius anti-aliasing.
+    scale: f32,
 }
 
 #[derive(Debug, Default, Clone)]
@@ -70,19 +72,13 @@ impl<R: NiriRenderer> ClippedSurfaceRenderElement<R> {
             * Mat3::from_scale(buf_size / src_size)
             * Mat3::from_translation(-src_loc / buf_size);
 
-        let uniforms = vec![
-            Uniform::new("niri_scale", scale.x as f32),
-            Uniform::new("geo_size", (geometry.size.w as f32, geometry.size.h as f32)),
-            Uniform::new("corner_radius", <[f32; 4]>::from(corner_radius)),
-            mat3_uniform("input_to_geo", input_to_geo),
-        ];
-
         Self {
             inner: elem,
             program,
             corner_radius,
             geometry,
-            uniforms,
+            input_to_geo,
+            scale: scale.x as f32,
         }
     }
 
@@ -121,21 +117,21 @@ impl<R: NiriRenderer> ClippedSurfaceRenderElement<R> {
         let bottom_left = corner_radius.bottom_left as f64;
 
         [
-            Rectangle::new(geo.loc, Size::from((top_left, top_left))),
+            Rectangle::from_loc_and_size(geo.loc, (top_left, top_left)),
-            Rectangle::new(
+            Rectangle::from_loc_and_size(
-                Point::from((geo.loc.x + geo.size.w - top_right, geo.loc.y)),
+                (geo.loc.x + geo.size.w - top_right, geo.loc.y),
-                Size::from((top_right, top_right)),
+                (top_right, top_right),
             ),
-            Rectangle::new(
+            Rectangle::from_loc_and_size(
-                Point::from((
+                (
                     geo.loc.x + geo.size.w - bottom_right,
                     geo.loc.y + geo.size.h - bottom_right,
-                )),
-                Size::from((bottom_right, bottom_right)),
                 ),
-            Rectangle::new(
+                (bottom_right, bottom_right),
-                Point::from((geo.loc.x, geo.loc.y + geo.size.h - bottom_left)),
+            ),
-                Size::from((bottom_left, bottom_left)),
+            Rectangle::from_loc_and_size(
+                (geo.loc.x, geo.loc.y + geo.size.h - bottom_left),
+                (bottom_left, bottom_left),
             ),
         ]
     }
@@ -224,7 +220,18 @@ impl RenderElement<GlesRenderer> for ClippedSurfaceRenderElement<GlesRenderer> {
         damage: &[Rectangle<i32, Physical>],
         opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), GlesError> {
-        frame.override_default_tex_program(self.program.clone(), self.uniforms.clone());
+        frame.override_default_tex_program(
+            self.program.clone(),
+            vec![
+                Uniform::new("niri_scale", self.scale),
+                Uniform::new(
+                    "geo_size",
+                    (self.geometry.size.w as f32, self.geometry.size.h as f32),
+                ),
+                Uniform::new("corner_radius", <[f32; 4]>::from(self.corner_radius)),
+                mat3_uniform("input_to_geo", self.input_to_geo),
+            ],
+        );
         RenderElement::<GlesRenderer>::draw(&self.inner, frame, src, dst, damage, opaque_regions)?;
         frame.clear_tex_program_override();
         Ok(())
@@ -248,9 +255,17 @@ impl<'render> RenderElement<TtyRenderer<'render>>
         damage: &[Rectangle<i32, Physical>],
         opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), TtyRendererError<'render>> {
-        frame
+        frame.as_gles_frame().override_default_tex_program(
-            .as_gles_frame()
+            self.program.clone(),
-            .override_default_tex_program(self.program.clone(), self.uniforms.clone());
+            vec![
+                Uniform::new(
+                    "geo_size",
+                    (self.geometry.size.w as f32, self.geometry.size.h as f32),
+                ),
+                Uniform::new("corner_radius", <[f32; 4]>::from(self.corner_radius)),
+                mat3_uniform("input_to_geo", self.input_to_geo),
+            ],
+        );
         RenderElement::draw(&self.inner, frame, src, dst, damage, opaque_regions)?;
         frame.as_gles_frame().clear_tex_program_override();
         Ok(())

src/render_helpers/damage.rs

@@ -54,7 +54,7 @@ impl Element for ExtraDamage {
     }
 
     fn src(&self) -> Rectangle<f64, Buffer> {
-        Rectangle::from_size(Size::from((1., 1.)))
+        Rectangle::from_loc_and_size((0., 0.), (1., 1.))
     }
 
     fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {

src/render_helpers/mod.rs

@@ -31,7 +31,6 @@ pub mod resize;
 pub mod resources;
 pub mod shader_element;
 pub mod shaders;
-pub mod shadow;
 pub mod snapshot;
 pub mod solid_color;
 pub mod surface;
@@ -114,11 +113,6 @@ impl<E> SplitElements<E> {
         popups.extend(normal);
         popups
     }
-
-    pub fn extend(&mut self, other: SplitElements<E>) {
-        self.popups.extend(other.popups);
-        self.normal.extend(other.normal);
-    }
 }
 
 impl ToRenderElement for BakedBuffer<TextureBuffer<GlesTexture>> {
@@ -217,7 +211,7 @@ pub fn render_and_download(
 
     let buffer_size = size.to_logical(1).to_buffer(1, Transform::Normal);
     let mapping = renderer
-        .copy_framebuffer(Rectangle::from_size(buffer_size), fourcc)
+        .copy_framebuffer(Rectangle::from_loc_and_size((0, 0), buffer_size), fourcc)
         .context("error copying framebuffer")?;
     Ok(mapping)
 }
@@ -301,7 +295,7 @@ fn render_elements(
     elements: impl Iterator<Item = impl RenderElement<GlesRenderer>>,
 ) -> anyhow::Result<SyncPoint> {
     let transform = transform.invert();
-    let output_rect = Rectangle::from_size(transform.transform_size(size));
+    let output_rect = Rectangle::from_loc_and_size((0, 0), transform.transform_size(size));
 
     let mut frame = renderer
         .render(size, transform)

src/render_helpers/renderer.rs

@@ -46,7 +46,7 @@ impl AsGlesRenderer for GlesRenderer {
     }
 }
 
-impl AsGlesRenderer for TtyRenderer<'_> {
+impl<'render> AsGlesRenderer for TtyRenderer<'render> {
     fn as_gles_renderer(&mut self) -> &mut GlesRenderer {
         self.as_mut()
     }
@@ -66,7 +66,7 @@ impl<'frame> AsGlesFrame<'frame> for GlesFrame<'frame> {
     }
 }
 
-impl<'frame> AsGlesFrame<'frame> for TtyFrame<'_, 'frame> {
+impl<'render, 'frame> AsGlesFrame<'frame> for TtyFrame<'render, 'frame> {
     fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame> {
         self.as_mut()
     }

src/render_helpers/resize.rs

@@ -43,7 +43,7 @@ impl ResizeRenderElement {
         let tex_next_geo_scaled = tex_next_geo.to_f64().upscale(scale_next);
         let combined_geo = tex_prev_geo_scaled.merge(tex_next_geo_scaled).to_i32_up();
 
-        let area = Rectangle::new(
+        let area = Rectangle::from_loc_and_size(
             area.loc + combined_geo.loc.to_logical(scale),
             combined_geo.size.to_logical(scale),
         );

src/render_helpers/shader_element.rs

@@ -193,7 +193,7 @@ impl ShaderRenderElement {
             program,
             id: Id::new(),
             commit_counter: CommitCounter::default(),
-            area: Rectangle::from_size(size),
+            area: Rectangle::from_loc_and_size((0., 0.), size),
             opaque_regions: opaque_regions.unwrap_or_default(),
             scale,
             alpha,
@@ -227,14 +227,12 @@ impl ShaderRenderElement {
         size: Size<f64, Logical>,
         opaque_regions: Option<Vec<Rectangle<f64, Logical>>>,
         scale: f32,
-        alpha: f32,
         uniforms: Vec<Uniform<'static>>,
         textures: HashMap<String, GlesTexture>,
     ) {
         self.area.size = size;
         self.opaque_regions = opaque_regions.unwrap_or_default();
         self.scale = scale;
-        self.alpha = alpha;
         self.additional_uniforms = uniforms;
         self.textures = textures;
 
@@ -257,7 +255,7 @@ impl Element for ShaderRenderElement {
     }
 
     fn src(&self) -> Rectangle<f64, Buffer> {
-        Rectangle::from_size(Size::from((1., 1.)))
+        Rectangle::from_loc_and_size((0., 0.), (1., 1.))
     }
 
     fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
@@ -272,7 +270,7 @@ impl Element for ShaderRenderElement {
     }
 
     fn alpha(&self) -> f32 {
-        self.alpha
+        1.0
     }
 
     fn kind(&self) -> Kind {
@@ -310,13 +308,13 @@ impl RenderElement<GlesRenderer> for ShaderRenderElement {
 
                 let rect_constrained_loc = rect
                     .loc
-                    .constrain(Rectangle::from_extremities((0, 0), dest_size.to_point()));
+                    .constrain(Rectangle::from_extemities((0, 0), dest_size.to_point()));
                 let rect_clamped_size = rect.size.clamp(
                     (0, 0),
                     (dest_size.to_point() - rect_constrained_loc).to_size(),
                 );
 
-                let rect = Rectangle::new(rect_constrained_loc, rect_clamped_size);
+                let rect = Rectangle::from_loc_and_size(rect_constrained_loc, rect_clamped_size);
                 [
                     rect.loc.x as f32,
                     rect.loc.y as f32,
@@ -330,13 +328,13 @@ impl RenderElement<GlesRenderer> for ShaderRenderElement {
 
                 let rect_constrained_loc = rect
                     .loc
-                    .constrain(Rectangle::from_extremities((0, 0), dest_size.to_point()));
+                    .constrain(Rectangle::from_extemities((0, 0), dest_size.to_point()));
                 let rect_clamped_size = rect.size.clamp(
                     (0, 0),
                     (dest_size.to_point() - rect_constrained_loc).to_size(),
                 );
 
-                let rect = Rectangle::new(rect_constrained_loc, rect_clamped_size);
+                let rect = Rectangle::from_loc_and_size(rect_constrained_loc, rect_clamped_size);
                 // Add the 4 f32s per damage rectangle for each of the 6 vertices.
                 (0..6).flat_map(move |_| {
                     [

src/render_helpers/shaders/mod.rs

@@ -11,7 +11,6 @@ use super::shader_element::ShaderProgram;
 
 pub struct Shaders {
     pub border: Option<ShaderProgram>,
-    pub shadow: Option<ShaderProgram>,
     pub clipped_surface: Option<GlesTexProgram>,
     pub resize: Option<ShaderProgram>,
     pub custom_resize: RefCell<Option<ShaderProgram>>,
@@ -22,7 +21,6 @@ pub struct Shaders {
 #[derive(Debug, Clone, Copy)]
 pub enum ProgramType {
     Border,
-    Shadow,
     Resize,
     Close,
     Open,
@@ -55,26 +53,6 @@ impl Shaders {
         })
         .ok();
 
-        let shadow = ShaderProgram::compile(
-            renderer,
-            include_str!("shadow.frag"),
-            &[
-                UniformName::new("shadow_color", UniformType::_4f),
-                UniformName::new("sigma", UniformType::_1f),
-                UniformName::new("input_to_geo", UniformType::Matrix3x3),
-                UniformName::new("geo_size", UniformType::_2f),
-                UniformName::new("corner_radius", UniformType::_4f),
-                UniformName::new("window_input_to_geo", UniformType::Matrix3x3),
-                UniformName::new("window_geo_size", UniformType::_2f),
-                UniformName::new("window_corner_radius", UniformType::_4f),
-            ],
-            &[],
-        )
-        .map_err(|err| {
-            warn!("error compiling shadow shader: {err:?}");
-        })
-        .ok();
-
         let clipped_surface = renderer
             .compile_custom_texture_shader(
                 include_str!("clipped_surface.frag"),
@@ -98,7 +76,6 @@ impl Shaders {
 
         Self {
             border,
-            shadow,
             clipped_surface,
             resize,
             custom_resize: RefCell::new(None),
@@ -144,7 +121,6 @@ impl Shaders {
     pub fn program(&self, program: ProgramType) -> Option<ShaderProgram> {
         match program {
             ProgramType::Border => self.border.clone(),
-            ProgramType::Shadow => self.shadow.clone(),
             ProgramType::Resize => self
                 .custom_resize
                 .borrow()

src/render_helpers/shaders/shadow.frag

@@ -1,142 +0,0 @@
-precision highp float;
-
-#if defined(DEBUG_FLAGS)
-uniform float niri_tint;
-#endif
-
-uniform float niri_alpha;
-uniform float niri_scale;
-
-uniform vec2 niri_size;
-varying vec2 niri_v_coords;
-
-uniform vec4 shadow_color;
-uniform float sigma;
-
-uniform mat3 input_to_geo;
-uniform vec2 geo_size;
-uniform vec4 corner_radius;
-
-uniform mat3 window_input_to_geo;
-uniform vec2 window_geo_size;
-uniform vec4 window_corner_radius;
-
-// Based on: https://madebyevan.com/shaders/fast-rounded-rectangle-shadows/
-//
-// License: CC0 (http://creativecommons.org/publicdomain/zero/1.0/)
-
-// A standard gaussian function, used for weighting samples
-float gaussian(float x, float sigma) {
-  const float pi = 3.141592653589793;
-  return exp(-(x * x) / (2.0 * sigma * sigma)) / (sqrt(2.0 * pi) * sigma);
-}
-
-// This approximates the error function, needed for the gaussian integral
-vec2 erf(vec2 x) {
-  vec2 s = sign(x), a = abs(x);
-  x = 1.0 + (0.278393 + (0.230389 + 0.078108 * (a * a)) * a) * a;
-  x *= x;
-  return s - s / (x * x);
-}
-
-// Return the blurred mask along the x dimension
-float roundedBoxShadowX(float x, float y, float sigma, float corner, vec2 halfSize) {
-  float delta = min(halfSize.y - corner - abs(y), 0.0);
-  float curved = halfSize.x - corner + sqrt(max(0.0, corner * corner - delta * delta));
-  vec2 integral = 0.5 + 0.5 * erf((x + vec2(-curved, curved)) * (sqrt(0.5) / sigma));
-  return integral.y - integral.x;
-}
-
-// Return the mask for the shadow of a box from lower to upper
-float roundedBoxShadow(vec2 lower, vec2 upper, vec2 point, float sigma, float corner) {
-  // Center everything to make the math easier
-  vec2 center = (lower + upper) * 0.5;
-  vec2 halfSize = (upper - lower) * 0.5;
-  point -= center;
-
-  // The signal is only non-zero in a limited range, so don't waste samples
-  float low = point.y - halfSize.y;
-  float high = point.y + halfSize.y;
-  float start = clamp(-3.0 * sigma, low, high);
-  float end = clamp(3.0 * sigma, low, high);
-
-  // Accumulate samples (we can get away with surprisingly few samples)
-  float step = (end - start) / 4.0;
-  float y = start + step * 0.5;
-  float value = 0.0;
-  for (int i = 0; i < 4; i++) {
-    value += roundedBoxShadowX(point.x, point.y - y, sigma, corner, halfSize) * gaussian(y, sigma) * step;
-    y += step;
-  }
-
-  return value;
-}
-
-float rounding_alpha(vec2 coords, vec2 size, vec4 corner_radius) {
-    vec2 center;
-    float radius;
-
-    if (coords.x < corner_radius.x && coords.y < corner_radius.x) {
-        radius = corner_radius.x;
-        center = vec2(radius, radius);
-    } else if (size.x - corner_radius.y < coords.x && coords.y < corner_radius.y) {
-        radius = corner_radius.y;
-        center = vec2(size.x - radius, radius);
-    } else if (size.x - corner_radius.z < coords.x && size.y - corner_radius.z < coords.y) {
-        radius = corner_radius.z;
-        center = vec2(size.x - radius, size.y - radius);
-    } else if (coords.x < corner_radius.w && size.y - corner_radius.w < coords.y) {
-        radius = corner_radius.w;
-        center = vec2(radius, size.y - radius);
-    } else {
-        return 1.0;
-    }
-
-    float dist = distance(coords, center);
-    float half_px = 0.5 / niri_scale;
-    return 1.0 - smoothstep(radius - half_px, radius + half_px, dist);
-}
-
-void main() {
-    vec3 coords_geo = input_to_geo * vec3(niri_v_coords, 1.0);
-    vec3 coords_window_geo = window_input_to_geo * vec3(niri_v_coords, 1.0);
-
-    vec4 color = shadow_color;
-
-    float shadow_value;
-    if (sigma < 0.1) {
-        // With low enough sigma just draw a rounded rectangle.
-        shadow_value = rounding_alpha(coords_geo.xy, geo_size, corner_radius);
-    } else {
-        shadow_value = roundedBoxShadow(
-            vec2(0.0, 0.0),
-            geo_size,
-            coords_geo.xy,
-            sigma,
-            // FIXME: figure out how to blur with different corner radii.
-            //
-            // GTK seems to call blurring separately for the rect and for the 4 corners:
-            // https://gitlab.gnome.org/GNOME/gtk/-/blob/gtk-4-16/gsk/gpu/shaders/gskgpuboxshadow.glsl
-            corner_radius.x
-        );
-    }
-    color = color * shadow_value;
-
-    // Cut out the inside of the window geometry if requested.
-    if (window_geo_size != vec2(0.0, 0.0)) {
-        if (0.0 <= coords_window_geo.x && coords_window_geo.x <= window_geo_size.x
-                && 0.0 <= coords_window_geo.y && coords_window_geo.y <= window_geo_size.y) {
-            float alpha = rounding_alpha(coords_window_geo.xy, window_geo_size, window_corner_radius);
-            color = color * (1.0 - alpha);
-        }
-    }
-
-    color = color * niri_alpha;
-
-#if defined(DEBUG_FLAGS)
-    if (niri_tint == 1.0)
-        color = vec4(0.0, 0.2, 0.0, 0.2) + color * 0.8;
-#endif
-
-    gl_FragColor = color;
-}

src/render_helpers/shadow.rs

@@ -1,265 +0,0 @@
-use std::collections::HashMap;
-
-use glam::{Mat3, Vec2};
-use niri_config::{Color, CornerRadius};
-use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
-use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer, Uniform};
-use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
-use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform};
-
-use super::renderer::NiriRenderer;
-use super::shader_element::ShaderRenderElement;
-use super::shaders::{mat3_uniform, ProgramType, Shaders};
-use crate::backend::tty::{TtyFrame, TtyRenderer, TtyRendererError};
-
-/// Renders a rounded rectangle shadow.
-#[derive(Debug, Clone)]
-pub struct ShadowRenderElement {
-    inner: ShaderRenderElement,
-    params: Parameters,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-struct Parameters {
-    size: Size<f64, Logical>,
-    geometry: Rectangle<f64, Logical>,
-    color: Color,
-    sigma: f32,
-    corner_radius: CornerRadius,
-    // Should only be used for visual improvements, i.e. corner radius anti-aliasing.
-    scale: f32,
-    alpha: f32,
-
-    window_geometry: Rectangle<f64, Logical>,
-    window_corner_radius: CornerRadius,
-}
-
-impl ShadowRenderElement {
-    #[allow(clippy::too_many_arguments)]
-    pub fn new(
-        size: Size<f64, Logical>,
-        geometry: Rectangle<f64, Logical>,
-        color: Color,
-        sigma: f32,
-        corner_radius: CornerRadius,
-        scale: f32,
-        window_geometry: Rectangle<f64, Logical>,
-        window_corner_radius: CornerRadius,
-        alpha: f32,
-    ) -> Self {
-        let inner = ShaderRenderElement::empty(ProgramType::Shadow, Kind::Unspecified);
-        let mut rv = Self {
-            inner,
-            params: Parameters {
-                size,
-                geometry,
-                color,
-                sigma,
-                corner_radius,
-                scale,
-                alpha,
-                window_geometry,
-                window_corner_radius,
-            },
-        };
-        rv.update_inner();
-        rv
-    }
-
-    pub fn empty() -> Self {
-        let inner = ShaderRenderElement::empty(ProgramType::Shadow, Kind::Unspecified);
-        Self {
-            inner,
-            params: Parameters {
-                size: Default::default(),
-                geometry: Default::default(),
-                color: Default::default(),
-                sigma: 0.,
-                corner_radius: Default::default(),
-                scale: 1.,
-                alpha: 1.,
-                window_geometry: Default::default(),
-                window_corner_radius: Default::default(),
-            },
-        }
-    }
-
-    pub fn damage_all(&mut self) {
-        self.inner.damage_all();
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub fn update(
-        &mut self,
-        size: Size<f64, Logical>,
-        geometry: Rectangle<f64, Logical>,
-        color: Color,
-        sigma: f32,
-        corner_radius: CornerRadius,
-        scale: f32,
-        window_geometry: Rectangle<f64, Logical>,
-        window_corner_radius: CornerRadius,
-        alpha: f32,
-    ) {
-        let params = Parameters {
-            size,
-            geometry,
-            color,
-            sigma,
-            alpha,
-            corner_radius,
-            scale,
-            window_geometry,
-            window_corner_radius,
-        };
-        if self.params == params {
-            return;
-        }
-
-        self.params = params;
-        self.update_inner();
-    }
-
-    fn update_inner(&mut self) {
-        let Parameters {
-            size,
-            geometry,
-            color,
-            sigma,
-            alpha,
-            corner_radius,
-            scale,
-            window_geometry,
-            window_corner_radius,
-        } = self.params;
-
-        let area_size = Vec2::new(size.w as f32, size.h as f32);
-
-        let geo_loc = Vec2::new(geometry.loc.x as f32, geometry.loc.y as f32);
-        let geo_size = Vec2::new(geometry.size.w as f32, geometry.size.h as f32);
-
-        let input_to_geo =
-            Mat3::from_scale(area_size) * Mat3::from_translation(-geo_loc / area_size);
-
-        let window_geo_loc = Vec2::new(window_geometry.loc.x as f32, window_geometry.loc.y as f32);
-        let window_geo_size =
-            Vec2::new(window_geometry.size.w as f32, window_geometry.size.h as f32);
-
-        let window_input_to_geo =
-            Mat3::from_scale(area_size) * Mat3::from_translation(-window_geo_loc / area_size);
-
-        self.inner.update(
-            size,
-            None,
-            scale,
-            alpha,
-            vec![
-                Uniform::new("shadow_color", color.to_array_premul()),
-                Uniform::new("sigma", sigma),
-                mat3_uniform("input_to_geo", input_to_geo),
-                Uniform::new("geo_size", geo_size.to_array()),
-                Uniform::new("corner_radius", <[f32; 4]>::from(corner_radius)),
-                mat3_uniform("window_input_to_geo", window_input_to_geo),
-                Uniform::new("window_geo_size", window_geo_size.to_array()),
-                Uniform::new(
-                    "window_corner_radius",
-                    <[f32; 4]>::from(window_corner_radius),
-                ),
-            ],
-            HashMap::new(),
-        );
-    }
-
-    pub fn with_location(mut self, location: Point<f64, Logical>) -> Self {
-        self.inner = self.inner.with_location(location);
-        self
-    }
-
-    pub fn has_shader(renderer: &mut impl NiriRenderer) -> bool {
-        Shaders::get(renderer)
-            .program(ProgramType::Shadow)
-            .is_some()
-    }
-}
-
-impl Default for ShadowRenderElement {
-    fn default() -> Self {
-        Self::empty()
-    }
-}
-
-impl Element for ShadowRenderElement {
-    fn id(&self) -> &Id {
-        self.inner.id()
-    }
-
-    fn current_commit(&self) -> CommitCounter {
-        self.inner.current_commit()
-    }
-
-    fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
-        self.inner.geometry(scale)
-    }
-
-    fn transform(&self) -> Transform {
-        self.inner.transform()
-    }
-
-    fn src(&self) -> Rectangle<f64, Buffer> {
-        self.inner.src()
-    }
-
-    fn damage_since(
-        &self,
-        scale: Scale<f64>,
-        commit: Option<CommitCounter>,
-    ) -> DamageSet<i32, Physical> {
-        self.inner.damage_since(scale, commit)
-    }
-
-    fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
-        self.inner.opaque_regions(scale)
-    }
-
-    fn alpha(&self) -> f32 {
-        self.inner.alpha()
-    }
-
-    fn kind(&self) -> Kind {
-        self.inner.kind()
-    }
-}
-
-impl RenderElement<GlesRenderer> for ShadowRenderElement {
-    fn draw(
-        &self,
-        frame: &mut GlesFrame<'_>,
-        src: Rectangle<f64, Buffer>,
-        dst: Rectangle<i32, Physical>,
-        damage: &[Rectangle<i32, Physical>],
-        opaque_regions: &[Rectangle<i32, Physical>],
-    ) -> Result<(), GlesError> {
-        RenderElement::<GlesRenderer>::draw(&self.inner, frame, src, dst, damage, opaque_regions)
-    }
-
-    fn underlying_storage(&self, renderer: &mut GlesRenderer) -> Option<UnderlyingStorage> {
-        self.inner.underlying_storage(renderer)
-    }
-}
-
-impl<'render> RenderElement<TtyRenderer<'render>> for ShadowRenderElement {
-    fn draw(
-        &self,
-        frame: &mut TtyFrame<'_, '_>,
-        src: Rectangle<f64, Buffer>,
-        dst: Rectangle<i32, Physical>,
-        damage: &[Rectangle<i32, Physical>],
-        opaque_regions: &[Rectangle<i32, Physical>],
-    ) -> Result<(), TtyRendererError<'render>> {
-        RenderElement::<TtyRenderer<'_>>::draw(&self.inner, frame, src, dst, damage, opaque_regions)
-    }
-
-    fn underlying_storage(&self, renderer: &mut TtyRenderer<'render>) -> Option<UnderlyingStorage> {
-        self.inner.underlying_storage(renderer)
-    }
-}

src/render_helpers/solid_color.rs

@@ -85,7 +85,7 @@ impl SolidColorRenderElement {
         alpha: f32,
         kind: Kind,
     ) -> Self {
-        let geo = Rectangle::new(location.into(), buffer.size());
+        let geo = Rectangle::from_loc_and_size(location, buffer.size());
         let color = buffer.color * alpha;
         Self::new(buffer.id.clone(), geo, buffer.commit, color, kind)
     }
@@ -125,7 +125,7 @@ impl Element for SolidColorRenderElement {
     }
 
     fn src(&self) -> Rectangle<f64, Buffer> {
-        Rectangle::from_size(Size::from((1., 1.)))
+        Rectangle::from_loc_and_size((0., 0.), (1., 1.))
     }
 
     fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
@@ -134,7 +134,8 @@ impl Element for SolidColorRenderElement {
 
     fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
         if self.color.is_opaque() {
-            let rect = Rectangle::from_size(self.geometry.size).to_physical_precise_down(scale);
+            let rect = Rectangle::from_loc_and_size((0., 0.), self.geometry.size)
+                .to_physical_precise_down(scale);
             OpaqueRegions::from_slice(&[rect])
         } else {
             OpaqueRegions::default()

src/render_helpers/texture.rs

@@ -157,7 +157,7 @@ impl<T: Texture> Element for TextureRenderElement<T> {
     }
 
     fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
-        let logical_geo = Rectangle::new(self.location, self.logical_size());
+        let logical_geo = Rectangle::from_loc_and_size(self.location, self.logical_size());
         logical_geo.to_physical_precise_round(scale)
     }
 
@@ -174,7 +174,9 @@ impl<T: Texture> Element for TextureRenderElement<T> {
                     &self.buffer.logical_size(),
                 )
             })
-            .unwrap_or_else(|| Rectangle::from_size(self.buffer.texture.size()).to_f64())
+            .unwrap_or_else(|| {
+                Rectangle::from_loc_and_size((0, 0), self.buffer.texture.size()).to_f64()
+            })
     }
 
     fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {

src/tests/client.rs

@@ -1,526 +0,0 @@
-use std::cmp::min;
-use std::collections::HashMap;
-use std::fmt;
-use std::fmt::Write as _;
-use std::os::unix::net::UnixStream;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
-use std::time::Duration;
-
-use calloop::EventLoop;
-use calloop_wayland_source::WaylandSource;
-use single_pixel_buffer::v1::client::wp_single_pixel_buffer_manager_v1::WpSinglePixelBufferManagerV1;
-use smithay::reexports::wayland_protocols::wp::single_pixel_buffer;
-use smithay::reexports::wayland_protocols::wp::viewporter::client::wp_viewport::WpViewport;
-use smithay::reexports::wayland_protocols::wp::viewporter::client::wp_viewporter::WpViewporter;
-use smithay::reexports::wayland_protocols::xdg::shell::client::xdg_surface::{self, XdgSurface};
-use smithay::reexports::wayland_protocols::xdg::shell::client::xdg_toplevel::{self, XdgToplevel};
-use smithay::reexports::wayland_protocols::xdg::shell::client::xdg_wm_base::{self, XdgWmBase};
-use wayland_backend::client::Backend;
-use wayland_client::globals::Global;
-use wayland_client::protocol::wl_buffer::{self, WlBuffer};
-use wayland_client::protocol::wl_callback::{self, WlCallback};
-use wayland_client::protocol::wl_compositor::WlCompositor;
-use wayland_client::protocol::wl_display::WlDisplay;
-use wayland_client::protocol::wl_output::{self, WlOutput};
-use wayland_client::protocol::wl_registry::{self, WlRegistry};
-use wayland_client::protocol::wl_surface::{self, WlSurface};
-use wayland_client::{Connection, Dispatch, Proxy as _, QueueHandle};
-
-use crate::utils::id::IdCounter;
-
-pub struct Client {
-    pub id: ClientId,
-    pub event_loop: EventLoop<'static, State>,
-    pub connection: Connection,
-    pub qh: QueueHandle<State>,
-    pub display: WlDisplay,
-    pub state: State,
-}
-
-pub struct State {
-    pub qh: QueueHandle<State>,
-
-    pub globals: Vec<Global>,
-    pub outputs: HashMap<WlOutput, String>,
-
-    pub compositor: Option<WlCompositor>,
-    pub xdg_wm_base: Option<XdgWmBase>,
-    pub spbm: Option<WpSinglePixelBufferManagerV1>,
-    pub viewporter: Option<WpViewporter>,
-
-    pub windows: Vec<Window>,
-}
-
-pub struct Window {
-    pub qh: QueueHandle<State>,
-    pub spbm: WpSinglePixelBufferManagerV1,
-
-    pub surface: WlSurface,
-    pub xdg_surface: XdgSurface,
-    pub xdg_toplevel: XdgToplevel,
-    pub viewport: WpViewport,
-    pub pending_configure: Configure,
-    pub configures_received: Vec<(u32, Configure)>,
-    pub close_requested: bool,
-
-    pub configures_looked_at: usize,
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct Configure {
-    pub size: (i32, i32),
-    pub bounds: Option<(i32, i32)>,
-    pub states: Vec<xdg_toplevel::State>,
-}
-
-#[derive(Default)]
-pub struct SyncData {
-    pub done: AtomicBool,
-}
-
-static CLIENT_ID_COUNTER: IdCounter = IdCounter::new();
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ClientId(u64);
-
-impl ClientId {
-    fn next() -> ClientId {
-        ClientId(CLIENT_ID_COUNTER.next())
-    }
-}
-
-impl fmt::Display for Configure {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "size: {} × {}, ", self.size.0, self.size.1)?;
-        if let Some(bounds) = self.bounds {
-            write!(f, "bounds: {} × {}, ", bounds.0, bounds.1)?;
-        } else {
-            write!(f, "bounds: none, ")?;
-        }
-        write!(f, "states: {:?}", self.states)?;
-        Ok(())
-    }
-}
-
-impl Client {
-    pub fn new(stream: UnixStream) -> Self {
-        let id = ClientId::next();
-
-        let event_loop = EventLoop::try_new().unwrap();
-        let backend = Backend::connect(stream).unwrap();
-        let connection = Connection::from_backend(backend);
-        let queue = connection.new_event_queue();
-        let qh = queue.handle();
-        WaylandSource::new(connection.clone(), queue)
-            .insert(event_loop.handle())
-            .unwrap();
-
-        let display = connection.display();
-        let _registry = display.get_registry(&qh, ());
-        connection.flush().unwrap();
-
-        let state = State {
-            qh: qh.clone(),
-            globals: Vec::new(),
-            outputs: HashMap::new(),
-            compositor: None,
-            xdg_wm_base: None,
-            spbm: None,
-            viewporter: None,
-            windows: Vec::new(),
-        };
-
-        Self {
-            id,
-            event_loop,
-            connection,
-            qh,
-            display,
-            state,
-        }
-    }
-
-    pub fn dispatch(&mut self) {
-        self.event_loop
-            .dispatch(Duration::ZERO, &mut self.state)
-            .unwrap();
-    }
-
-    pub fn send_sync(&self) -> Arc<SyncData> {
-        let data = Arc::new(SyncData::default());
-        self.display.sync(&self.qh, data.clone());
-        self.connection.flush().unwrap();
-        data
-    }
-
-    pub fn create_window(&mut self) -> &mut Window {
-        self.state.create_window()
-    }
-
-    pub fn window(&mut self, surface: &WlSurface) -> &mut Window {
-        self.state.window(surface)
-    }
-
-    pub fn output(&mut self, name: &str) -> WlOutput {
-        self.state
-            .outputs
-            .iter()
-            .find(|(_, v)| *v == name)
-            .unwrap()
-            .0
-            .clone()
-    }
-}
-
-impl State {
-    pub fn create_window(&mut self) -> &mut Window {
-        let compositor = self.compositor.as_ref().unwrap();
-        let xdg_wm_base = self.xdg_wm_base.as_ref().unwrap();
-        let viewporter = self.viewporter.as_ref().unwrap();
-
-        let surface = compositor.create_surface(&self.qh, ());
-        let xdg_surface = xdg_wm_base.get_xdg_surface(&surface, &self.qh, ());
-        let xdg_toplevel = xdg_surface.get_toplevel(&self.qh, ());
-        let viewport = viewporter.get_viewport(&surface, &self.qh, ());
-
-        let window = Window {
-            qh: self.qh.clone(),
-            spbm: self.spbm.clone().unwrap(),
-
-            surface,
-            xdg_surface,
-            xdg_toplevel,
-            viewport,
-            pending_configure: Configure::default(),
-            configures_received: Vec::new(),
-            close_requested: false,
-
-            configures_looked_at: 0,
-        };
-
-        self.windows.push(window);
-        self.windows.last_mut().unwrap()
-    }
-
-    pub fn window(&mut self, surface: &WlSurface) -> &mut Window {
-        self.windows
-            .iter_mut()
-            .find(|w| w.surface == *surface)
-            .unwrap()
-    }
-}
-
-impl Window {
-    pub fn commit(&self) {
-        self.surface.commit();
-    }
-
-    pub fn ack_last(&self) {
-        let serial = self.configures_received.last().unwrap().0;
-        self.xdg_surface.ack_configure(serial);
-    }
-
-    pub fn ack_last_and_commit(&self) {
-        self.ack_last();
-        self.commit();
-    }
-
-    pub fn attach_new_buffer(&self) {
-        let buffer = self.spbm.create_u32_rgba_buffer(0, 0, 0, 0, &self.qh, ());
-        self.surface.attach(Some(&buffer), 0, 0);
-    }
-
-    pub fn set_size(&self, w: u16, h: u16) {
-        self.viewport.set_destination(i32::from(w), i32::from(h));
-    }
-
-    pub fn set_fullscreen(&self, output: Option<&WlOutput>) {
-        self.xdg_toplevel.set_fullscreen(output);
-    }
-
-    pub fn unset_fullscreen(&self) {
-        self.xdg_toplevel.unset_fullscreen();
-    }
-
-    pub fn set_parent(&self, parent: Option<&XdgToplevel>) {
-        self.xdg_toplevel.set_parent(parent);
-    }
-
-    pub fn set_title(&self, title: &str) {
-        self.xdg_toplevel.set_title(title.to_owned());
-    }
-
-    pub fn recent_configures(&mut self) -> impl Iterator<Item = &Configure> {
-        let start = self.configures_looked_at;
-        self.configures_looked_at = self.configures_received.len();
-        self.configures_received[start..].iter().map(|(_, c)| c)
-    }
-
-    pub fn format_recent_configures(&mut self) -> String {
-        let mut buf = String::new();
-        for configure in self.recent_configures() {
-            if !buf.is_empty() {
-                buf.push('\n');
-            }
-            write!(buf, "{configure}").unwrap();
-        }
-        buf
-    }
-}
-
-impl Dispatch<WlCallback, Arc<SyncData>> for State {
-    fn event(
-        _state: &mut Self,
-        _proxy: &WlCallback,
-        event: <WlCallback as wayland_client::Proxy>::Event,
-        data: &Arc<SyncData>,
-        _conn: &Connection,
-        _qhandle: &QueueHandle<Self>,
-    ) {
-        match event {
-            wl_callback::Event::Done { .. } => data.done.store(true, Ordering::Relaxed),
-            _ => unreachable!(),
-        }
-    }
-}
-
-impl Dispatch<WlRegistry, ()> for State {
-    fn event(
-        state: &mut Self,
-        registry: &WlRegistry,
-        event: <WlRegistry as wayland_client::Proxy>::Event,
-        _data: &(),
-        _conn: &Connection,
-        qh: &QueueHandle<Self>,
-    ) {
-        match event {
-            wl_registry::Event::Global {
-                name,
-                interface,
-                version,
-            } => {
-                if interface == WlCompositor::interface().name {
-                    let version = min(version, WlCompositor::interface().version);
-                    state.compositor = Some(registry.bind(name, version, qh, ()));
-                } else if interface == XdgWmBase::interface().name {
-                    let version = min(version, XdgWmBase::interface().version);
-                    state.xdg_wm_base = Some(registry.bind(name, version, qh, ()));
-                } else if interface == WpSinglePixelBufferManagerV1::interface().name {
-                    let version = min(version, WpSinglePixelBufferManagerV1::interface().version);
-                    state.spbm = Some(registry.bind(name, version, qh, ()));
-                } else if interface == WpViewporter::interface().name {
-                    let version = min(version, WpViewporter::interface().version);
-                    state.viewporter = Some(registry.bind(name, version, qh, ()));
-                } else if interface == WlOutput::interface().name {
-                    let version = min(version, WlOutput::interface().version);
-                    let output = registry.bind(name, version, qh, ());
-                    state.outputs.insert(output, String::new());
-                }
-
-                let global = Global {
-                    name,
-                    interface,
-                    version,
-                };
-                state.globals.push(global);
-            }
-            wl_registry::Event::GlobalRemove { .. } => (),
-            _ => unreachable!(),
-        }
-    }
-}
-
-impl Dispatch<WlOutput, ()> for State {
-    fn event(
-        state: &mut Self,
-        output: &WlOutput,
-        event: <WlOutput as wayland_client::Proxy>::Event,
-        _data: &(),
-        _conn: &Connection,
-        _qhandle: &QueueHandle<Self>,
-    ) {
-        match event {
-            wl_output::Event::Geometry { .. } => (),
-            wl_output::Event::Mode { .. } => (),
-            wl_output::Event::Done => (),
-            wl_output::Event::Scale { .. } => (),
-            wl_output::Event::Name { name } => {
-                *state.outputs.get_mut(output).unwrap() = name;
-            }
-            wl_output::Event::Description { .. } => (),
-            _ => unreachable!(),
-        }
-    }
-}
-
-impl Dispatch<WlCompositor, ()> for State {
-    fn event(
-        _state: &mut Self,
-        _proxy: &WlCompositor,
-        _event: <WlCompositor as wayland_client::Proxy>::Event,
-        _data: &(),
-        _conn: &Connection,
-        _qhandle: &QueueHandle<Self>,
-    ) {
-        unreachable!()
-    }
-}
-
-impl Dispatch<XdgWmBase, ()> for State {
-    fn event(
-        _state: &mut Self,
-        xdg_wm_base: &XdgWmBase,
-        event: <XdgWmBase as wayland_client::Proxy>::Event,
-        _data: &(),
-        _conn: &Connection,
-        _qhandle: &QueueHandle<Self>,
-    ) {
-        match event {
-            xdg_wm_base::Event::Ping { serial } => {
-                xdg_wm_base.pong(serial);
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-
-impl Dispatch<WlSurface, ()> for State {
-    fn event(
-        _state: &mut Self,
-        _proxy: &WlSurface,
-        event: <WlSurface as wayland_client::Proxy>::Event,
-        _data: &(),
-        _conn: &Connection,
-        _qhandle: &QueueHandle<Self>,
-    ) {
-        match event {
-            wl_surface::Event::Enter { .. } => (),
-            wl_surface::Event::Leave { .. } => (),
-            wl_surface::Event::PreferredBufferScale { .. } => (),
-            wl_surface::Event::PreferredBufferTransform { .. } => (),
-            _ => unreachable!(),
-        }
-    }
-}
-
-impl Dispatch<XdgSurface, ()> for State {
-    fn event(
-        state: &mut Self,
-        xdg_surface: &XdgSurface,
-        event: <XdgSurface as wayland_client::Proxy>::Event,
-        _data: &(),
-        _conn: &Connection,
-        _qhandle: &QueueHandle<Self>,
-    ) {
-        match event {
-            xdg_surface::Event::Configure { serial } => {
-                let window = state
-                    .windows
-                    .iter_mut()
-                    .find(|w| w.xdg_surface == *xdg_surface)
-                    .unwrap();
-                let configure = window.pending_configure.clone();
-                window.configures_received.push((serial, configure));
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-
-impl Dispatch<XdgToplevel, ()> for State {
-    fn event(
-        state: &mut Self,
-        xdg_toplevel: &XdgToplevel,
-        event: <XdgToplevel as wayland_client::Proxy>::Event,
-        _data: &(),
-        _conn: &Connection,
-        _qhandle: &QueueHandle<Self>,
-    ) {
-        let window = state
-            .windows
-            .iter_mut()
-            .find(|w| w.xdg_toplevel == *xdg_toplevel)
-            .unwrap();
-
-        match event {
-            xdg_toplevel::Event::Configure {
-                width,
-                height,
-                states,
-            } => {
-                let configure = &mut window.pending_configure;
-                configure.size = (width, height);
-                configure.states = states
-                    .chunks_exact(4)
-                    .flat_map(TryInto::<[u8; 4]>::try_into)
-                    .map(u32::from_ne_bytes)
-                    .flat_map(xdg_toplevel::State::try_from)
-                    .collect();
-            }
-            xdg_toplevel::Event::Close => {
-                window.close_requested = true;
-            }
-            xdg_toplevel::Event::ConfigureBounds { width, height } => {
-                window.pending_configure.bounds = Some((width, height));
-            }
-            xdg_toplevel::Event::WmCapabilities { .. } => (),
-            _ => unreachable!(),
-        }
-    }
-}
-
-impl Dispatch<WlBuffer, ()> for State {
-    fn event(
-        _state: &mut Self,
-        _proxy: &WlBuffer,
-        event: <WlBuffer as wayland_client::Proxy>::Event,
-        _data: &(),
-        _conn: &Connection,
-        _qhandle: &QueueHandle<Self>,
-    ) {
-        match event {
-            wl_buffer::Event::Release => (),
-            _ => unreachable!(),
-        }
-    }
-}
-
-impl Dispatch<WpSinglePixelBufferManagerV1, ()> for State {
-    fn event(
-        _state: &mut Self,
-        _proxy: &WpSinglePixelBufferManagerV1,
-        _event: <WpSinglePixelBufferManagerV1 as wayland_client::Proxy>::Event,
-        _data: &(),
-        _conn: &Connection,
-        _qhandle: &QueueHandle<Self>,
-    ) {
-        unreachable!()
-    }
-}
-
-impl Dispatch<WpViewporter, ()> for State {
-    fn event(
-        _state: &mut Self,
-        _proxy: &WpViewporter,
-        _event: <WpViewporter as wayland_client::Proxy>::Event,
-        _data: &(),
-        _conn: &Connection,
-        _qhandle: &QueueHandle<Self>,
-    ) {
-        unreachable!()
-    }
-}
-
-impl Dispatch<WpViewport, ()> for State {
-    fn event(
-        _state: &mut Self,
-        _proxy: &WpViewport,
-        _event: <WpViewport as wayland_client::Proxy>::Event,
-        _data: &(),
-        _conn: &Connection,
-        _qhandle: &QueueHandle<Self>,
-    ) {
-        unreachable!()
-    }
-}