packaging: PKGBUILD, changelog and tag-driven release workflow (0.4.0)

Same shape as uhhm/gdo: a v* tag runs makepkg on the x86_64 (ergo, "bare") and aarch64 (klokka) runners, uploads to the [uhhm] Arch registry under namespace bl, and creates a release with the changelog section as notes. The tag must agree with PKGBUILD's pkgver and Cargo.toml's version. Without a REGISTRY_TOKEN secret the publish step warns and skips so the build is still verified. Version jumps to 0.4.0 because upstream already tagged v0.2.1 and v0.3.0 on this history before the rewrite reset Cargo.toml to 0.2.0. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
clippy: clean up all warnings
2026-10-03 09:28:22 +00:00 · 2026-10-03 09:20:25 +00:00 · 2026-10-03 09:16:15 +00:00 · 2026-10-03 09:15:57 +00:00 · 2026-10-03 09:15:56 +00:00 · 2026-10-03 09:15:56 +00:00
28 changed files with 803 additions and 431 deletions
@@ -0,0 +1,114 @@
 name: Release
 # A `v*` tag builds the package on each architecture's own runner
 # (x86_64 on ergo's bare runner, aarch64 on klokka's) and uploads it
 # to the [uhhm] Arch registry, like uhhm/gdo and bl/djdeck. Hosts then
 # `pacman -S wldash`. The tag has to agree with PKGBUILD's pkgver and
 # Cargo.toml's version, and CHANGELOG.md has to have the section; a
 # release with the tag's notes is created from the x86_64 job.
 on:
  push:
    tags: ["v*"]
 jobs:
  package:
    strategy:
      matrix:
        include:
          - arch: x86_64
            runs-on: bare
            # The bare runner's shared toolchain and caches, with the
            # writable cargo home uhhm/iris and uhhm/gdo use.
            cargo_home: /var/local/cargo-target/iris-cargo-home
            rustc_wrapper: /usr/bin/sccache
            rustup_home: /var/local/rustup
            target_dir: /var/local/cargo-target
          - arch: aarch64
            runs-on: aarch64
            # klokka's host runner: rustup's stable (step below), defaults everywhere.
            cargo_home: ""
            rustc_wrapper: ""
            rustup_home: ""
            target_dir: ""
    runs-on: ${{ matrix.runs-on }}
    env:
      CARGO_HOME: ${{ matrix.cargo_home }}
      RUSTC_WRAPPER: ${{ matrix.rustc_wrapper }}
      RUSTUP_HOME: ${{ matrix.rustup_home }}
      CARGO_TARGET_DIR: ${{ matrix.target_dir }}
      PATH: /var/local/cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/bin
      SCCACHE_DIR: /var/local/sccache
      SCCACHE_SERVER_PORT: "4228"
    steps:
      # v4 built-in checkout: native Go, needs no Node (the aarch64 host runner
      # has none) and keeps the token out of a fetch URL.
      - name: Checkout
        uses: builtin:checkout
      # klokka's runner has rustup but no default toolchain, so its cargo
      # proxy refuses to run without this.
      - name: Install Rust stable (aarch64)
        if: matrix.arch == 'aarch64'
        uses: dtolnay/rust-toolchain@stable
      - name: Check tag matches pkgver and Cargo.toml
        run: |
          want="${GITHUB_REF_NAME#v}"
          have=$(sed -n 's/^pkgver=//p' PKGBUILD)
          [ "$want" = "$have" ] || { echo "tag $GITHUB_REF_NAME != pkgver $have" >&2; exit 1; }
          cargo_ver=$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -1)
          [ "$want" = "$cargo_ver" ] || { echo "tag $GITHUB_REF_NAME != Cargo.toml version $cargo_ver" >&2; exit 1; }
          notes=$(awk -v v="$want" '/^## /{p = ($2 == v)} p' CHANGELOG.md | tail -n +2)
          [ -n "$(printf "%s" "$notes" | tr -d "[:space:]")" ] || { echo "CHANGELOG.md has no section for $GITHUB_REF_NAME" >&2; exit 1; }
      # Bare runners are never mutated by CI: wldash's system libraries
      # (dbus, libpulse, libxkbcommon, fontconfig, wayland) must already be
      # installed on the host. Fail loud if one is missing.
      - name: Check system build deps
        run: |
          missing=""
          for lib in dbus-1 libpulse xkbcommon fontconfig wayland-client; do
            pkg-config --exists "$lib" || missing="$missing $lib"
          done
          [ -z "$missing" ] || { echo "::error::bare runner missing:$missing — install once on the host" >&2; exit 1; }
      # -d: cargo is the shared toolchain, not a pacman package the
      # runner could verify. Builds and tests from the checkout. Empty
      # env values above are unset here so cargo's defaults apply.
      - name: Build package
        run: |
          for v in CARGO_HOME RUSTC_WRAPPER RUSTUP_HOME CARGO_TARGET_DIR; do
            eval "[ -n \"\$$v\" ]" || unset "$v"
          done
          makepkg -f -d --noconfirm
      # REGISTRY_TOKEN is a write:package token for bl, a secret on this
      # repo. The registry namespace is always bl: pacman.conf's [uhhm]
      # points at /api/packages/bl/arch/uhhm. Without the secret the build
      # still runs so the tag is verified; re-run the job once it is set.
      - name: Publish to the Arch package registry
        run: |
          set -euo pipefail
          if [ -z "${{ secrets.REGISTRY_TOKEN }}" ]; then
            echo "::warning::REGISTRY_TOKEN not set — skipping Arch registry publish"
            exit 0
          fi
          for pkg in $(makepkg --packagelist); do
            echo "==> $pkg"
            curl --fail-with-body --user "bl:${{ secrets.REGISTRY_TOKEN }}" \
              --upload-file "$pkg" \
              "${{ gitea.server_url }}/api/packages/bl/arch/uhhm"
          done
      - name: Release notes
        if: matrix.arch == 'x86_64'
        run: |
          set -euo pipefail
          tag="${{ github.ref_name }}"
          api="${{ github.server_url }}/api/v1/repos/${{ github.repository }}"
          auth="Authorization: token ${{ secrets.GITHUB_TOKEN }}"
          notes=$(awk -v v="${tag#v}" '/^## /{p = ($2 == v)} p' CHANGELOG.md | tail -n +2)
          body=$(jq -n --arg tag "$tag" --arg notes "$notes" '{tag_name: $tag, name: $tag, body: $notes}')
          curl -sf -X POST -H "$auth" -H 'Content-Type: application/json' -d "$body" "$api/releases" > /dev/null \
            || echo "release $tag exists"
@@ -0,0 +1,16 @@
 # Changelog
 ## 0.4.0 (2026-10-03)
 First release of the project.uhhm.no fork, packaged for the `[uhhm]` Arch registry. Numbering: upstream's old code base was tagged up to v0.3.0 and the rewrite called itself 0.2.0; this fork continues above both so pacman sees a monotonic version.
 - Launcher: the prompt cursor was a byte offset in some places and a grapheme index in others, so typing æøå and then End or another key crashed wldash. The cursor is grapheme-based everywhere, Up stops at the last row, mouse selection can't underflow, and all desktop Exec field codes (`%i`, `%c`, `%k`, `%%`, ...) are stripped.
 - No more aborting on machines without a backlight, battery or PulseAudio: `/sys/class/backlight` itself was taken for a device, UPower's always-present DisplayDevice for a battery, and a failed audio connection panicked a thread (fatal with `panic = "abort"`).
 - Redraws: `Geometry::expand` computed the damage height from the wrong field; buffer refcounts no longer underflow; `wl_shm_pool`s are destroyed on resize.
 - Input: a key-repeat rate of 0 divided by zero; Escape is now seen by the launcher first so the prompt is saved for Ctrl+R; the first layer-surface configure always lays out.
 - Config: `/etc/wldash/config.yml` takes precedence over `~/.config/wldash/config.yml` when present (machine-local layout on NFS-shared homes); `--config` overrides both. Errors print one line and exit 1 instead of panicking.
 - Housekeeping: `memmap` → `memmap2`, unused `shlex` dropped, zero rustc/clippy warnings, rustfmt applied, unit tests for the prompt, Exec parsing and geometry.
 ## 0.2.0
 Upstream (kennylevinsen/wldash) rewrite, the state this fork started from.
@@ -462,16 +462,6 @@ version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
 [[package]]
 name = "memmap"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6585fd95e7bb50d6cc31e20d4cf9afb4e2ba16c5846fc76793f11218da9c475b"
 dependencies = [
 "libc",
 "winapi",
 ]
 [[package]]
 name = "memmap2"
 version = "0.9.5"
@@ -809,12 +799,6 @@ dependencies = [
 "digest",
 ]
 [[package]]
 name = "shlex"
 version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 [[package]]
 name = "simd-json"
 version = "0.13.8"
@@ -1280,8 +1264,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
 [[package]]
-name = "wldash2"
+name = "wldash"
-version = "0.1.0"
+version = "0.4.0"
 dependencies = [
 "calloop",
 "chrono",
@@ -1289,13 +1273,12 @@ dependencies = [
 "fontconfig",
 "fuzzy-matcher",
 "libpulse-binding",
- "memmap",
+ "memmap2",
 "nix 0.26.4",
 "rcalc_lib",
 "rusttype",
 "serde",
 "serde_yaml",
 "shlex",
 "simd-json",
 "unicode-segmentation",
 "walkdir",
@@ -1,19 +1,22 @@
 [package]
-name = "wldash2"
+name = "wldash"
-version = "0.1.0"
+version = "0.4.0"
-edition = "2021"
+edition = "2024"
 [profile.release]
 #debug = true
 lto = "fat"
 panic = "abort"
 [features]
 default = ["fontconfig"]
 [dependencies]
 wayland-client = { version = "0.30", features = ["calloop", "log"] }
 wayland-protocols = { version = "0.30", features = ["client", "unstable", "staging"] }
 wayland-protocols-wlr = { version = "0.1", features = ["client"] }
 nix = "0.26" # 0.27 is breaking
-memmap = "0.7"
+memmap2 = "0.9"
 fontconfig = { version = "0.8.0", optional = true }
 rusttype = "0.9"
 # fontdue = "0.7"
@@ -24,7 +27,6 @@ walkdir = "2.4"
 unicode-segmentation = "1.10"
 fuzzy-matcher = "0.3"
 shlex = "1.3"
 xkbcommon = { version = "0.8", features = ["wayland"] }
@@ -0,0 +1,40 @@
 # Maintainer: Bendik Aagaard Lynghaug <bendik.lynghaug@gmail.com>
 # Built from the tagged checkout by .gitea/workflows/release.yml, once
 # per architecture, and uploaded to the [uhhm] registry on
 # project.uhhm.no (namespace bl). pkgver is the version; the tag has
 # to agree with it and with Cargo.toml.
 pkgname=wldash
 pkgver=0.4.0
 pkgrel=1
 pkgdesc="Dashboard/launcher/control-panel for wlroots-style Wayland compositors (layer-shell)"
 arch=('x86_64' 'aarch64')
 url="https://project.uhhm.no/bl/wldash"
 license=('GPL-3.0-only')
 depends=('glibc' 'gcc-libs' 'dbus' 'libpulse' 'libxkbcommon' 'fontconfig' 'wayland')
 makedepends=('cargo')
 optdepends=('upower: battery widget'
            'pipewire-pulse: volume widget (or pulseaudio)')
 # !lto: Cargo.toml already does lto = "fat"; makepkg's -flto in RUSTFLAGS
 # would only fight it. !debug: panic = "abort" release, nothing to strip.
 options=('!debug' '!lto')
 # Sources are the checkout itself: makepkg resolves local sources by
 # basename next to the PKGBUILD, so the tagged tree CI builds from is
 # the source of truth, as in uhhm/gdo.
 build() {
    cd "$startdir"
    cargo build --release --locked
 }
 check() {
    cd "$startdir"
    cargo test --release --locked
 }
 package() {
    cd "$startdir"
    install -Dm755 "${CARGO_TARGET_DIR:-target}/release/wldash" "$pkgdir/usr/bin/wldash"
    install -Dm644 README.md "$pkgdir/usr/share/doc/$pkgname/README.md"
    install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
 }
@@ -6,16 +6,29 @@ A dashboard/launcher/control-panel thing for Wayland. Requires wlr-layer-shell-u
 Consider this alpha-quality: While it works, *everything* is subject to change with a moments notice. You may end up pulling in the latest changes, and *poof*, wldash suddenly turns into an artisan espresso machine.
 ## Rewrite note
 wldash has received a significant rewrite. The old version is available in the wldash1 branch for now.
 ## This fork
 This is a maintained fork of [kennylevinsen/wldash](https://github.com/kennylevinsen/wldash)
 living at <https://project.uhhm.no/bl/wldash>. On top of upstream it fixes a number of
 crashes (non-ASCII input in the launcher, machines without a backlight, battery or
 PulseAudio, key-repeat rate 0, ...), corrects redraw damage tracking, and prefers a
 machine-local `/etc/wldash/config.yml` over the per-user config when present, which keeps
 per-host layouts apart on NFS-shared homes.
 ## How to use
-1. Checkout: `git clone https://github.com/kennylevinsen/wldash`
+1. Checkout: `git clone https://project.uhhm.no/bl/wldash`
 2. Build: `cargo build --release`
 3. Put somewhere: `cp target/release/wldash /usr/local/bin/wldash`
 4. Run: `wldash`
-To see the default configuration, run `wldash print-config`. To configure, place a file in `$XDG_CONFIG_HOME/wldash/config.yaml` (or if `XDG_CONFIG_HOME` is not set, `~/.config/wldash/config.yaml`). JSON is also currently supported.
+To generate a new default configuration, run `wldash --write-default-config`. To configure, edit `$XDG_CONFIG_HOME/wldash/config.yml` (or if `XDG_CONFIG_HOME` is not set, `~/.config/wldash/config.yml`). If `/etc/wldash/config.yml` exists it takes precedence over the per-user file; `--config FILE` overrides both.
-Notable settings: `outptuMode` can be `active` or `all`, `scale` can be set to `2` to half the buffer size, and the widgets (and their layout) can be configured.
+To regenerate the desktop file cache, run `wldash --desktop-refresh`.
 For more info, look in `src/config.rs`.
@@ -63,9 +76,6 @@ The launcher also accepts prefix operators to change its mode:
 ## Notable missing features:
 - Scaling of any kind - all sizes are currently hardcoded in pixels
 - Configurability
 - Cleanup and reorganization
 - Proper line editor for the launcher
 ## How to discuss
@@ -1,5 +1,4 @@
 use std::{
    ffi::CStr,
    fs::File,
    io,
    os::unix::io::{FromRawFd, RawFd},
@@ -16,11 +15,11 @@ use nix::{
    unistd,
 };
-use memmap::MmapMut;
+use memmap2::MmapMut;
 use wayland_client::{
    protocol::{wl_buffer, wl_shm, wl_shm_pool},
    Dispatch, QueueHandle,
    protocol::{wl_buffer, wl_shm, wl_shm_pool},
 };
 use crate::color::Color;
@@ -30,10 +29,7 @@ fn create_shm_fd() -> io::Result<RawFd> {
    // Only try memfd on linux
    #[cfg(target_os = "linux")]
    loop {
-        match memfd::memfd_create(
+        match memfd::memfd_create(c"wldash", memfd::MemFdCreateFlag::MFD_CLOEXEC) {
            CStr::from_bytes_with_nul(b"wldash\0").unwrap(),
            memfd::MemFdCreateFlag::MFD_CLOEXEC,
        ) {
            Ok(fd) => return Ok(fd),
            Err(Errno::EINTR) => continue,
            Err(Errno::ENOSYS) => break,
@@ -78,11 +74,13 @@ fn create_shm_fd() -> io::Result<RawFd> {
 }
 pub struct ShmBuffer {
    // Keeps the memfd alive for as long as the mapping and pool exist.
    #[allow(dead_code)]
    pub file: File,
    pub mmap: MmapMut,
    pub pool: wl_shm_pool::WlShmPool,
    pub buffer: wl_buffer::WlBuffer,
    pub refcnt: u32,
    pub id: u32,
    pub last_damage: Vec<Geometry>,
 }
@@ -94,7 +92,6 @@ impl ShmBuffer {
        height: i32,
        stride: i32,
        format: wl_shm::Format,
        id: u32,
    ) -> io::Result<ShmBuffer>
    where
        D: Dispatch<wl_shm_pool::WlShmPool, ()> + Dispatch<wl_buffer::WlBuffer, ()> + 'static,
@@ -102,16 +99,16 @@ impl ShmBuffer {
        let mem_fd = create_shm_fd()?;
        let file = unsafe { File::from_raw_fd(mem_fd) };
        file.set_len((height * stride) as u64)?;
-        let pool = shm.create_pool(mem_fd, height * stride, &qh, ());
+        let pool = shm.create_pool(mem_fd, height * stride, qh, ());
-        let mmap = unsafe { MmapMut::map_mut(&file).unwrap() };
+        let mmap = unsafe { MmapMut::map_mut(&file)? };
-        let buffer = pool.create_buffer(0, width, height, stride, format, &qh, ());
+        let buffer = pool.create_buffer(0, width, height, stride, format, qh, ());
        Ok(ShmBuffer {
            refcnt: 0,
            file,
            mmap,
            pool,
            buffer,
            id,
            last_damage: Vec::new(),
        })
    }
@@ -121,37 +118,33 @@ impl ShmBuffer {
    }
    pub fn release(&mut self) {
-        self.refcnt -= 1;
+        // A compositor may release a buffer we never considered acquired
        // (e.g. after a resize); never underflow and wedge the buffer.
        self.refcnt = self.refcnt.saturating_sub(1);
    }
 }
 pub struct BufferManager {
    pub buffers: Vec<ShmBuffer>,
    pub next_id: u32,
 }
 impl BufferManager {
    pub fn new() -> BufferManager {
        BufferManager {
            buffers: Vec::new(),
            next_id: 0,
        }
    }
    pub fn clear_buffers(&mut self) {
        for buf in self.buffers.iter_mut() {
-            buf.buffer.destroy()
+            buf.buffer.destroy();
            buf.pool.destroy();
        }
        self.buffers.clear()
    }
    pub fn next_buffer(&mut self) -> Option<&mut ShmBuffer> {
-        for buf in self.buffers.iter_mut() {
+        self.buffers.iter_mut().find(|buf| buf.refcnt == 0)
            if buf.refcnt == 0 {
                return Some(buf);
            }
        }
        None
    }
    pub fn add_buffer<D>(
@@ -162,18 +155,15 @@ impl BufferManager {
    ) where
        D: Dispatch<wl_shm_pool::WlShmPool, ()> + Dispatch<wl_buffer::WlBuffer, ()> + 'static,
    {
-        let mut buf = ShmBuffer::new(
+        let buf = ShmBuffer::new(
            wl_shm,
            qh,
            dimensions.0,
            dimensions.1,
            dimensions.0 * 4,
            wl_shm::Format::Argb8888,
            self.next_id,
        )
        .expect("unable to add buffer");
        self.next_id += 1;
        BufferView::new(&mut buf.mmap, (dimensions.0 as u32, dimensions.1 as u32));
        self.buffers.push(buf);
    }
 }
@@ -185,7 +175,7 @@ pub struct BufferView<'a> {
 }
 impl<'a> BufferView<'a> {
-    pub fn new(buf: &'a mut MmapMut, dimensions: (u32, u32)) -> BufferView {
+    pub fn new(buf: &'a mut MmapMut, dimensions: (u32, u32)) -> BufferView<'a> {
        let view = unsafe {
            std::slice::from_raw_parts_mut(
                buf.as_mut_ptr() as *mut u32,
@@ -208,7 +198,7 @@ impl<'a> BufferView<'a> {
        }
    }
-    pub fn subdimensions(&mut self, subdimensions: (u32, u32, u32, u32)) -> BufferView {
+    pub fn subdimensions(&mut self, subdimensions: (u32, u32, u32, u32)) -> BufferView<'_> {
        let bounds = self.get_bounds();
        if cfg!(debug_assertions)
            && (subdimensions.0 + subdimensions.2 > bounds.2
@@ -232,11 +222,11 @@ impl<'a> BufferView<'a> {
        }
    }
-    pub fn subgeometry(&mut self, geo: Geometry) -> BufferView {
+    pub fn subgeometry(&mut self, geo: Geometry) -> BufferView<'_> {
        self.subdimensions((geo.x, geo.y, geo.width, geo.height))
    }
-    pub fn offset(&mut self, offset: (u32, u32)) -> BufferView {
+    pub fn offset(&mut self, offset: (u32, u32)) -> BufferView<'_> {
        let bounds = self.get_bounds();
        if cfg!(debug_assertions) && (offset.0 > bounds.2 || offset.1 > bounds.3) {
            panic!(
@@ -6,7 +6,7 @@ use std::sync::{Arc, Mutex};
 use crate::{
    event::Events,
-    fonts::{find_font, FontMap},
+    fonts::{FontMap, find_font},
    widgets::{
        Backlight, Battery, Calendar, Clock, Date, HorizontalLayout, IndexedLayout, Interface,
        InvertedHorizontalLayout, InvertedVerticalLayout, Layout, Line, Margin, PulseAudio,
@@ -161,7 +161,7 @@ impl Config {
        Config {
            font_paths: Some(map),
-            widget: widget,
+            widget,
            mode: OperationMode::LayerSurface((1024, 768)),
            background: Some(0xFAFAFAFA),
            server: None,
@@ -251,7 +251,7 @@ impl Config {
        Config {
            font_paths: Some(map),
-            widget: widget,
+            widget,
            mode: if clay {
                OperationMode::XdgToplevel
            } else {
@@ -281,7 +281,7 @@ impl Widget {
    pub fn construct_widgets(
        self,
        v: &mut Vec<Box<dyn RealWidget>>,
-        mut fm: &mut FontMap,
+        fm: &mut FontMap,
        events: &Arc<Mutex<Events>>,
    ) {
        match self {
@@ -301,12 +301,12 @@ impl Widget {
            Widget::HorizontalLine(width) => v.push(Box::new(Line::new(width, false))),
            Widget::VerticalLine(width) => v.push(Box::new(Line::new(width, true))),
            Widget::Clock { font, font_size } => v.push(Box::new(Clock::new(
-                &mut fm,
+                fm,
                leak_or_default(font, "sans"),
                font_size,
            ))),
            Widget::Date { font, font_size } => v.push(Box::new(Date::new(
-                &mut fm,
+                fm,
                leak_or_default(font, "sans"),
                font_size,
            ))),
@@ -317,7 +317,7 @@ impl Widget {
                sections_x,
                sections_y,
            } => v.push(Box::new(Calendar::new(
-                &mut fm,
+                fm,
                leak_or_default(font_primary, "monospace"),
                leak_or_default(font_secondary, "sans"),
                font_size,
@@ -330,14 +330,14 @@ impl Widget {
                launch_cmd,
            } => v.push(Box::new(Interface::new(
                events.clone(),
-                &mut fm,
+                fm,
                leak_or_default(font, "sans"),
                font_size,
                launch_cmd,
            ))),
            Widget::Battery { font, font_size } => v.push(Box::new(Battery::new(
                events.clone(),
-                &mut fm,
+                fm,
                leak_or_default(font, "sans"),
                font_size,
            ))),
@@ -347,13 +347,13 @@ impl Widget {
                font_size,
            } => v.push(Box::new(Backlight::new(
                leak_or_none(device),
-                &mut fm,
+                fm,
                leak_or_default(font, "sans"),
                font_size,
            ))),
            Widget::PulseAudio { font, font_size } => v.push(Box::new(PulseAudio::new(
                events.clone(),
-                &mut fm,
+                fm,
                Box::leak(font.unwrap_or_else(|| "sans".to_string()).into_boxed_str()),
                font_size,
            ))),
@@ -1,7 +1,7 @@
 use crate::buffer::BufferView;
 use crate::{color::Color, fonts::FontRef};
-use rusttype::{point, Scale};
+use rusttype::{Scale, point};
 use std::collections::HashMap;
 struct CachedGlyph {
@@ -82,7 +82,7 @@ pub struct Font<'a> {
 }
 impl<'a> Font<'a> {
-    pub fn new(font: FontRef<'a>, size: f32) -> Font {
+    pub fn new(font: FontRef<'a>, size: f32) -> Font<'a> {
        Font {
            glyphs: HashMap::new(),
            font,
@@ -98,7 +98,7 @@ impl<'a> Font<'a> {
    pub fn add_str_to_cache(&mut self, s: &str) {
        for ch in s.chars() {
-            if self.glyphs.get(&ch).is_none() {
+            if !self.glyphs.contains_key(&ch) {
                let glyph = CachedGlyph::new(self.font, self.size, ch);
                self.glyphs.insert(ch, glyph);
            }
@@ -118,10 +118,10 @@ impl<'a> Font<'a> {
            let glyph = match self.glyphs.get(&ch) {
                Some(glyph) => glyph,
                None => {
-                    return Err(::std::io::Error::new(
+                    return Err(::std::io::Error::other(format!(
-                        ::std::io::ErrorKind::Other,
+                        "glyph for {:} not in cache",
-                        format!("glyph for {:} not in cache", ch),
+                        ch
-                    ))
+                    )));
                }
            };
            glyphs.push(glyph);
@@ -151,10 +151,10 @@ impl<'a> Font<'a> {
            let glyph = match self.glyphs.get(&ch) {
                Some(glyph) => glyph,
                None => {
-                    return Err(::std::io::Error::new(
+                    return Err(::std::io::Error::other(format!(
-                        ::std::io::ErrorKind::Other,
+                        "glyph for {:} not in cache",
-                        format!("glyph for {:} not in cache", ch),
+                        ch
-                    ))
+                    )));
                }
            };
            glyphs.push(glyph);
@@ -203,10 +203,10 @@ impl<'a> Font<'a> {
            let glyph = match self.glyphs.get(&ch) {
                Some(glyph) => glyph,
                None => {
-                    return Err(::std::io::Error::new(
+                    return Err(::std::io::Error::other(format!(
-                        ::std::io::ErrorKind::Other,
+                        "glyph for {:} not in cache",
-                        format!("glyph for {:} not in cache", ch),
+                        ch
-                    ))
+                    )));
                }
            };
            let width = glyph.advance;
@@ -252,10 +252,10 @@ impl<'a> Font<'a> {
            let glyph = match self.glyphs.get(&ch) {
                Some(glyph) => glyph,
                None => {
-                    return Err(::std::io::Error::new(
+                    return Err(::std::io::Error::other(format!(
-                        ::std::io::ErrorKind::Other,
+                        "glyph for {:} not in cache",
-                        format!("glyph for {:} not in cache", ch),
+                        ch
-                    ))
+                    )));
                }
            };
            glyphs.push(glyph);
@@ -284,10 +284,10 @@ impl<'a> Font<'a> {
            let glyph = match self.glyphs.get(&ch) {
                Some(glyph) => glyph,
                None => {
-                    return Err(::std::io::Error::new(
+                    return Err(::std::io::Error::other(format!(
-                        ::std::io::ErrorKind::Other,
+                        "glyph for {:} not in cache",
-                        format!("glyph for {:} not in cache", ch),
+                        ch
-                    ))
+                    )));
                }
            };
            glyphs.push(glyph);
@@ -56,6 +56,6 @@ impl Events {
    pub fn flush(&mut self) -> Vec<Event> {
        self.dirty = false;
-        self.events.drain(..).collect()
+        std::mem::take(&mut self.events)
    }
 }
@@ -70,10 +70,13 @@ impl PartialEq for ComparableF32 {
 impl Eq for ComparableF32 {}
 /// font name -> (font name, [(size, glyphs to preload)])
 type RequiredFonts = HashMap<&'static str, (&'static str, Vec<(f32, &'static str)>)>;
 pub struct FontMap {
    fonts: HashMap<(&'static str, ComparableF32), draw::Font<'static>>,
    font_paths: HashMap<&'static str, String>,
-    required_fonts: HashMap<&'static str, (&'static str, Vec<(f32, &'static str)>)>,
+    required_fonts: RequiredFonts,
 }
 impl FontMap {
@@ -12,12 +12,9 @@
 //! calloop event loop. Not doing so will prevent key repetition to work
 //! (but the rest of the functionnality will not be affected).
-use std::{
+use std::{default::Default, os::unix::io::OwnedFd};
    default::Default,
    os::unix::io::{AsRawFd, OwnedFd},
 };
-use wayland_client::{protocol::wl_keyboard, WEnum};
+use wayland_client::{WEnum, protocol::wl_keyboard};
 use xkbcommon::xkb;
 pub use xkbcommon::xkb::keysyms;
@@ -31,6 +28,7 @@ pub use self::state::ModifiersState;
 #[derive(Debug, Clone)]
 pub struct KeyEvent {
    #[allow(dead_code)]
    pub rawkey: u32,
    pub keysym: u32,
    pub state: WEnum<wl_keyboard::KeyState>,
@@ -46,7 +44,7 @@ pub struct KeymapDescription {
 impl KeymapDescription {
    fn new(fd: OwnedFd, size: u32) -> KeymapDescription {
-        KeymapDescription { fd: fd, size: size }
+        KeymapDescription { fd, size }
    }
 }
@@ -77,7 +75,9 @@ impl Keyboard {
            WEnum::Value(wl_keyboard::KeymapFormat::NoKeymap) => {
                // TODO: how to handle this (hopefully never occuring) case?
            }
-            _ => unreachable!(),
+            // Unknown format from a newer protocol version: ignore rather than
            // abort the whole process.
            _ => (),
        }
    }
@@ -1,11 +1,11 @@
 use std::time::Duration;
 use calloop::{
    EventSource, Poll, PostAction, Readiness, Token, TokenFactory,
    channel::{self, Channel},
    timer::{TimeoutAction, Timer},
    EventSource, Poll, PostAction, Readiness, Token, TokenFactory,
 };
-use wayland_client::{protocol::wl_keyboard, WEnum};
+use wayland_client::{WEnum, protocol::wl_keyboard};
 use super::KeyEvent;
@@ -89,6 +89,12 @@ impl EventSource for KeyRepeatSource {
                        _ => (),
                    },
                    RepeatMessage::RepeatInfo((new_rate, new_delay)) => {
                        // Per wl_keyboard.repeat_info, a rate of 0 disables
                        // key repeat entirely. Dividing by it would panic.
                        if new_rate == 0 {
                            *disabled = true;
                            key.take();
                        } else {
                            *rate = Duration::from_micros(1_000_000 / new_rate as u64);
                            *delay = Duration::from_millis(new_delay as u64);
                            *disabled = false;
@@ -96,6 +102,7 @@ impl EventSource for KeyRepeatSource {
                                timer.set_deadline(now + *delay);
                            }
                        }
                    }
                },
                channel::Event::Closed => {
@@ -129,7 +136,9 @@ impl EventSource for KeyRepeatSource {
            let mut next_deadline = deadline;
            if now - deadline > *rate * 2 {
                // We're way behind, let's just set a new time
-                println!("KeyRepeatSource::process_events: More than two repeat cycles behind, resetting");
+                println!(
                    "KeyRepeatSource::process_events: More than two repeat cycles behind, resetting"
                );
                next_deadline = now + *rate;
            } else {
                while next_deadline < now {
@@ -81,17 +81,15 @@ impl KbState {
    }
    pub(crate) fn compose_feed(&mut self, keysym: u32) -> Option<xkb::compose::FeedResult> {
-        match &mut self.xkb_compose_state {
+        self.xkb_compose_state
-            Some(compose_state) => Some(compose_state.feed(xkb::Keysym::new(keysym))),
+            .as_mut()
-            None => None,
+            .map(|compose_state| compose_state.feed(xkb::Keysym::new(keysym)))
        }
    }
    pub(crate) fn compose_status(&mut self) -> Option<xkb::compose::Status> {
-        match &mut self.xkb_compose_state {
+        self.xkb_compose_state
-            Some(compose_state) => Some(compose_state.status()),
+            .as_mut()
-            None => None,
+            .map(|compose_state| compose_state.status())
        }
    }
    pub(crate) fn compose_get_utf8(&mut self) -> Option<String> {
@@ -130,11 +128,11 @@ impl KbState {
    pub(crate) fn init_compose(&mut self) {
        let locale = env::var_os("LC_ALL")
-            .and_then(|v| if v.is_empty() { None } else { Some(v) })
+            .filter(|v| !v.is_empty())
            .or_else(|| env::var_os("LC_CTYPE"))
-            .and_then(|v| if v.is_empty() { None } else { Some(v) })
+            .filter(|v| !v.is_empty())
            .or_else(|| env::var_os("LANG"))
-            .and_then(|v| if v.is_empty() { None } else { Some(v) })
+            .filter(|v| !v.is_empty())
            .unwrap_or_else(|| "C".into());
        let compose_table = match xkb::compose::Table::new_from_locale(
@@ -12,8 +12,8 @@ mod widgets;
 use wayland_client::{Connection, QueueHandle, WaylandSource};
 use calloop::{
    timer::{TimeoutAction, Timer},
    EventLoop,
    timer::{TimeoutAction, Timer},
 };
 use chrono::{Duration, Local, Timelike};
@@ -30,10 +30,11 @@ use utils::{
 use widgets::{Geometry, Widget};
 use std::{
-    env,
+    env, fs,
    fs::File,
    io::{BufRead, BufReader, Write},
    os::unix::net::{UnixListener, UnixStream},
    path::Path,
    rc::Rc,
    thread,
 };
@@ -45,7 +46,8 @@ usage: wldash [OPTIONS]
 OPTIONS:
  --config CONFIG_FILE                     use the specified config file
-                                           (~/.config/wldash/config.yml by default)
+                                           (/etc/wldash/config.yml if present,
                                           else ~/.config/wldash/config.yml)
  --write-default-config [v1|v2|toplevel]  generate and write a new config file
                                           (v2 by default)
  --desktop-refresh                        refresh desktop file cache
@@ -53,18 +55,50 @@ OPTIONS:
    );
 }
 fn die(msg: String) -> ! {
    eprintln!("wldash: {}", msg);
    std::process::exit(1);
 }
 fn ensure_dir_exists(path: &str) {
    if let Err(err) = fs::create_dir_all(path) {
        die(format!("error creating directory {}: {}", path, err));
    }
 }
 fn create_required_directories() {
    let dir_config_wldash = format!("{}/wldash", xdg::config_folder());
    let dir_cache_wldash = format!("{}/wldash", xdg::cache_folder());
    ensure_dir_exists(&dir_config_wldash);
    ensure_dir_exists(&dir_cache_wldash);
 }
 /// Default config path. On a shared (e.g. NFS-roamed) home, a host-specific
 /// config at /etc/wldash/config.yml takes precedence over the roamed
 /// ~/.config/wldash/config.yml, so each machine can keep its own layout
 /// without conflicting. An explicit --config still overrides both.
 fn default_config_file() -> String {
    let etc = "/etc/wldash/config.yml";
    if Path::new(etc).exists() {
        return etc.to_string();
    }
    format!("{}/wldash/config.yml", xdg::config_folder())
 }
 fn main() {
    let mut args = env::args();
    // Skip program name
    _ = args.next();
-    let mut config_file = format!("{}/wldash/config.yml", xdg::config_folder());
+    create_required_directories();
    let mut config_file = default_config_file();
    loop {
        match args.next() {
            Some(ref s) if s == "--config" => match args.next() {
                Some(ref s) => config_file = s.clone(),
-                None => panic!("missing argument to --config"),
+                None => die("missing argument to --config".to_string()),
            },
            Some(ref s) if s == "--write-default-config" => {
                let config = match args.next() {
@@ -72,17 +106,23 @@ fn main() {
                    Some(ref s) if s == "v2" => Config::generate_v2(false),
                    Some(ref s) if s == "toplevel" => Config::generate_v2(true),
                    None => Config::generate_v2(false),
-                    Some(s) => panic!("unknown argument: {}", s),
+                    Some(s) => die(format!("unknown argument to --write-default-config: {}", s)),
                };
-                match File::create(config_file) {
+                match File::create(&config_file) {
-                    Ok(f) => serde_yaml::to_writer(f, &config).unwrap(),
+                    Ok(f) => {
-                    Err(_) => panic!("uh"),
+                        if let Err(e) = serde_yaml::to_writer(f, &config) {
                            die(format!("could not serialize config: {}", e));
                        }
                    }
                    Err(e) => die(format!("could not write {}: {}", config_file, e)),
                }
                std::process::exit(0);
            }
            Some(ref s) if s == "--desktop-refresh" => {
                let v = load_desktop_files();
-                write_desktop_cache(&v).unwrap();
+                if let Err(e) = write_desktop_cache(&v) {
                    die(format!("could not write desktop cache: {}", e));
                }
                std::process::exit(0);
            }
            Some(ref s) if s == "--help" => {
@@ -97,7 +137,10 @@ fn main() {
        }
    }
-    let conn = Connection::connect_to_env().unwrap();
+    let conn = match Connection::connect_to_env() {
        Ok(c) => c,
        Err(e) => die(format!("could not connect to the Wayland display: {}", e)),
    };
    let event_queue = conn.new_event_queue();
    let qhandle: QueueHandle<State> = event_queue.handle();
@@ -116,7 +159,7 @@ fn main() {
    handle
        .insert_source(
            WaylandSource::new(event_queue).expect("Could not create WaylandSource!"),
-            |_event, queue, mut state| queue.dispatch_pending(&mut state),
+            |_event, queue, state| queue.dispatch_pending(state),
        )
        .expect("Failed to insert event source!");
@@ -173,9 +216,15 @@ fn main() {
    let mut fm = FontMap::new();
-    let config: Config = match File::open(config_file) {
+    let config: Config = match File::open(&config_file) {
-        Ok(f) => serde_yaml::from_reader(f).unwrap(),
+        Ok(f) => match serde_yaml::from_reader(f) {
-        Err(_) => panic!("configuration file missing"),
+            Ok(c) => c,
            Err(e) => die(format!("invalid configuration {}: {}", config_file, e)),
        },
        Err(e) => die(format!(
            "could not open configuration {}: {} (try 'wldash --write-default-config')",
            config_file, e
        )),
    };
    if let Some(true) = config.server {
@@ -190,8 +239,7 @@ fn main() {
            .spawn(move || {
                let listener = UnixListener::bind(socket_path.clone()).unwrap();
                loop {
-                    match listener.accept() {
+                    if let Ok((stream, _)) = listener.accept() {
                        Ok((stream, _)) => {
                        let _ = thread::Builder::new().name("ipc_client".to_string()).spawn(
                            move || {
                                let r = BufReader::new(stream);
@@ -206,8 +254,6 @@ fn main() {
                            },
                        );
                    }
                        _ => (),
                    }
                }
            });
    }
@@ -261,7 +307,7 @@ fn main() {
        }
        let mut force = false;
-        if state.bufmgr.buffers.len() == 0 {
+        if state.bufmgr.buffers.is_empty() {
            state.add_buffer(&qhandle);
            force = true;
        }
@@ -285,7 +331,7 @@ fn main() {
            }
        };
-        if buf.last_damage.len() == 0 {
+        if buf.last_damage.is_empty() {
            for _ in 0..state.widgets.len() {
                buf.last_damage.push(Geometry::new());
            }
@@ -7,11 +7,11 @@ use std::{
 };
 use wayland_client::{
    Connection, Dispatch, QueueHandle, WEnum,
    protocol::{
        wl_buffer, wl_callback, wl_compositor, wl_keyboard, wl_pointer, wl_registry, wl_seat,
        wl_shm, wl_shm_pool, wl_subcompositor, wl_subsurface, wl_surface,
    },
    Connection, Dispatch, QueueHandle, WEnum,
 };
 use wayland_protocols::{
@@ -133,17 +133,16 @@ impl State {
            Ok(token) => token,
            Err(_) => return,
        };
-        match (
+        if let (Some(surface), Some(activation)) = (
            &self.main_surface.wl_surface,
            &self.protocols.xdg_activation,
        ) {
            (Some(surface), Some(activation)) => {
            activation.activate(key, surface);
            let activation_token = activation.get_activation_token(qh, ());
            activation_token.commit();
            unsafe {
                env::remove_var("XDG_ACTIVATION_TOKEN");
            }
            _ => (),
        }
    }
 }
@@ -331,9 +330,8 @@ impl Dispatch<wl_callback::WlCallback, ()> for State {
        _: &Connection,
        _: &QueueHandle<Self>,
    ) {
-        match event {
+        if let wl_callback::Event::Done { callback_data: _ } = event {
-            wl_callback::Event::Done { callback_data: _ } => state.ready = true,
+            state.ready = true
            _ => {}
        }
    }
 }
@@ -461,12 +459,15 @@ impl Dispatch<zwlr_layer_surface_v1::ZwlrLayerSurfaceV1, ()> for State {
                    (width, height) = (640, 480);
                }
                layer_surface.ack_configure(serial);
                let first_configure = !state.configured;
                state.configured = true;
                state.dirty = true;
                let dim = (width as i32, height as i32);
-                if state.configured && state.dimensions == dim {
+                // Always lay out on the first configure, even if the
                // compositor happens to hand us our placeholder dimensions.
                if !first_configure && state.dimensions == dim {
                    return;
                }
                state.bufmgr.clear_buffers();
@@ -478,8 +479,8 @@ impl Dispatch<zwlr_layer_surface_v1::ZwlrLayerSurfaceV1, ()> for State {
                    &Geometry {
                        x: 0,
                        y: 0,
-                        width: width as u32,
+                        width,
-                        height: height as u32,
+                        height,
                    },
                    state,
                );
@@ -656,25 +657,27 @@ impl Dispatch<wl_keyboard::WlKeyboard, ()> for State {
                state: kbstate,
                ..
            } => {
                if key == 1 {
                    state.running = false;
                    return;
                }
                state.keyboard.resolve();
                let k = state.keyboard.key(key, kbstate);
                let repeats = k.repeats;
                let ev = Event::KeyEvent(k);
                // Widgets see the key first so the launcher gets to save its
                // prompt on Escape (the early-return used to swallow it).
                for widget in state.widgets.iter_mut() {
                    widget.event(&ev);
                }
-                if repeats {
+                // Raw keycode 1 is KEY_ESC: fall back to quitting even when no
-                    if let Event::KeyEvent(k) = ev {
+                // keymap could be loaded and no widget handled it.
                if key == 1 && kbstate == WEnum::Value(wl_keyboard::KeyState::Pressed) {
                    state.running = false;
                    return;
                }
                if repeats && let Event::KeyEvent(k) = ev {
                    state
                        .keyrepeat_sender
                        .send(RepeatMessage::KeyEvent(k))
                        .unwrap();
                }
                }
                state.dirty = true;
            }
            wl_keyboard::Event::Modifiers {
@@ -733,8 +736,8 @@ impl Dispatch<wl_pointer::WlPointer, ()> for State {
                state.pointer = Some((surface_x, surface_y));
            }
            wl_pointer::Event::Leave { .. } => state.pointer = None,
-            wl_pointer::Event::Axis { axis, value, .. } => match state.pointer {
+            wl_pointer::Event::Axis { axis, value, .. } => {
-                Some((x, y)) => {
+                if let Some((x, y)) = state.pointer {
                    let axis = match axis {
                        WEnum::Value(wl_pointer::Axis::VerticalScroll) => {
                            PointerButton::ScrollVertical(value)
@@ -749,24 +752,22 @@ impl Dispatch<wl_pointer::WlPointer, ()> for State {
                        let geo = widget.geometry();
                        if geo.contains(pos) {
                            let pos = (pos.0 - geo.x, pos.1 - geo.y);
-                            let ev = Event::PointerEvent(PointerEvent {
+                            let ev = Event::PointerEvent(PointerEvent { button: axis, pos });
                                button: axis,
                                pos: pos,
                            });
                            widget.event(&ev);
                            state.dirty = true;
                            break;
                        }
                    }
                }
-                _ => (),
+            }
            },
            wl_pointer::Event::Button {
                button,
                state: button_state,
                ..
-            } => match (button, button_state, state.pointer) {
+            } => {
-                (button, WEnum::Value(wl_pointer::ButtonState::Pressed), Some((x, y))) => {
+                if let (button, WEnum::Value(wl_pointer::ButtonState::Pressed), Some((x, y))) =
                    (button, button_state, state.pointer)
                {
                    let button = match button {
                        BTN_LEFT => PointerButton::Left,
                        BTN_RIGHT => PointerButton::Right,
@@ -778,18 +779,14 @@ impl Dispatch<wl_pointer::WlPointer, ()> for State {
                        let geo = widget.geometry();
                        if geo.contains(pos) {
                            let pos = (pos.0 - geo.x, pos.1 - geo.y);
-                            let ev = Event::PointerEvent(PointerEvent {
+                            let ev = Event::PointerEvent(PointerEvent { button, pos });
                                button: button,
                                pos: pos,
                            });
                            widget.event(&ev);
                            state.dirty = true;
                            break;
                        }
                    }
                }
-                _ => (),
+            }
            },
            _ => (),
        }
    }
@@ -852,14 +849,11 @@ impl Dispatch<xdg_activation_token_v1::XdgActivationTokenV1, ()> for State {
        _: &Connection,
        _: &QueueHandle<Self>,
    ) {
-        match event {
+        if let xdg_activation_token_v1::Event::Done { token } = event {
            xdg_activation_token_v1::Event::Done { token } => {
            let ev = Event::TokenUpdate(token);
            for widget in state.widgets.iter_mut() {
                widget.event(&ev);
            }
        }
            _ => (),
        }
    }
 }
@@ -2,8 +2,10 @@ use std::{
    cmp::Ordering,
    collections::HashSet,
    error::Error,
-    fs::{read_to_string, File},
+    fs::{File, read_to_string},
    hash::{Hash, Hasher},
    io::{Error as io_error, ErrorKind},
    path::Path,
 };
 use serde::{self, Deserialize, Serialize};
@@ -12,7 +14,7 @@ use walkdir::WalkDir;
 use crate::utils::{inish, xdg};
-#[derive(Serialize, Deserialize, Clone, Debug, Eq, Hash)]
+#[derive(Serialize, Deserialize, Clone, Debug, Eq)]
 #[serde(rename_all = "snake_case")]
 pub struct Desktop {
    pub entry_type: String,
@@ -26,7 +28,7 @@ pub struct Desktop {
 }
 impl Desktop {
-    fn parse(f: &str) -> Result<Desktop, Box<dyn Error>> {
+    fn parse(f: &Path) -> Result<Desktop, Box<dyn Error>> {
        let s = read_to_string(f)?;
        let config = inish::parse(&s)?;
        match config.get("Desktop Entry") {
@@ -43,10 +45,10 @@ impl Desktop {
                    .map(|x| {
                        x.split(';')
                            .map(|y| y.trim().to_string())
-                            .filter(|z| z != "")
+                            .filter(|z| !z.is_empty())
                            .collect()
                    })
-                    .unwrap_or_else(|| vec![]),
+                    .unwrap_or_else(std::vec::Vec::new),
            }),
            None => Err(Box::new(io_error::new(
                ErrorKind::NotFound,
@@ -74,6 +76,13 @@ impl PartialEq for Desktop {
    }
 }
 // Must agree with PartialEq: equal entries (same name) must hash equally.
 impl Hash for Desktop {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.name.hash(state)
    }
 }
 pub fn load_desktop_cache() -> Result<Vec<Desktop>, Box<dyn Error>> {
    match File::open(format!("{}/wldash/desktop.json", xdg::cache_folder())) {
        Ok(f) => simd_json::from_reader(f).map_err(|e| e.into()),
@@ -95,9 +104,18 @@ pub fn load_desktop_files() -> Vec<Desktop> {
    let mut seen: HashSet<String> = HashSet::new();
    for dir in dirs {
-        for entry in WalkDir::new(format!("{}/applications", dir)) {
+        for entry in WalkDir::new(format!("{}/applications", dir))
-            if let Ok(entry) = entry {
+            .into_iter()
-                if let Ok(d) = Desktop::parse(entry.path().to_str().unwrap()) {
+            .flatten()
        {
            // Entries are often symlinks, so only rule out directories.
            if entry.file_type().is_dir()
                || entry.path().extension().and_then(|e| e.to_str()) != Some("desktop")
            {
                continue;
            }
            {
                if let Ok(d) = Desktop::parse(entry.path()) {
                    if d.hidden
                        || d.no_display
                        || (d.entry_type != "Application" && d.entry_type != "Link")
@@ -1,6 +1,6 @@
 use std::{collections::HashMap, error::Error};
-fn parse_field<'a>(line: &'a str) -> Result<(&'a str, &'a str), Box<dyn Error>> {
+fn parse_field(line: &str) -> Result<(&str, &str), Box<dyn Error>> {
    let split = match line.find('=') {
        Some(v) => v,
        None => return Err("expected equals sign on line, but found none".into()),
@@ -30,8 +30,8 @@ pub fn parse<'a>(s: &'a str) -> Result<Inish<'a>, Box<dyn Error>> {
            (Some('['), Some(']')) => {
                sections.insert(current_section_name, current_section);
                current_section = HashMap::new();
-                let len = line.bytes().count();
+                let len = line.len();
-                current_section_name = &line[1..len - 1].trim();
+                current_section_name = line[1..len - 1].trim();
            }
            (Some('['), v) => {
                return Err(format!(
@@ -1,6 +1,6 @@
 use std::{
    fs::{self, OpenOptions},
-    io::{Error, ErrorKind, Write},
+    io::{Error, Write},
    path::{Path, PathBuf},
 };
@@ -17,7 +17,7 @@ fn read_file_as_u64(path: &Path) -> Result<u64, Error> {
    let mut s = fs::read_to_string(path)?;
    s.pop();
    s.parse::<u64>()
-        .map_err(|_e| Error::new(ErrorKind::Other, "unable to parse value"))
+        .map_err(|_e| Error::other("unable to parse value"))
 }
 fn write_file_as_u64(path: &Path, value: u64) -> Result<(), Error> {
@@ -32,23 +32,35 @@ pub struct Backlight {
    dirty: bool,
 }
-impl Backlight {
+/// First device under /sys/class/backlight, if any. `min_depth(1)` skips the
-    fn update(&mut self) {
+/// class directory itself, which otherwise got picked up as a "device".
-        self.cur = read_file_as_u64(self.device_path.join("brightness").as_path()).unwrap();
+fn find_device() -> Option<PathBuf> {
-        self.max = read_file_as_u64(self.device_path.join("max_brightness").as_path()).unwrap();
+    WalkDir::new("/sys/class/backlight")
        .min_depth(1)
        .max_depth(1)
        .into_iter()
        .flatten()
        .map(|e| e.path().to_path_buf())
        .next()
 }
 impl Backlight {
    fn update(&mut self) {
        if let Ok(cur) = read_file_as_u64(self.device_path.join("brightness").as_path()) {
            self.cur = cur;
        }
        if let Ok(max) = read_file_as_u64(self.device_path.join("max_brightness").as_path()) {
            self.max = max;
        }
    }
    // Wraps the impl in the generic BarWidget on purpose.
    #[allow(clippy::new_ret_no_self)]
    pub fn new(path: Option<&str>, fm: &mut FontMap, font: &'static str, size: f32) -> BarWidget {
-        let mut device_path = None;
+        let device_path = match path {
-        if let Some(path) = path {
+            Some(path) => Some(Path::new("/sys/class/backlight").join(path)),
-            device_path = Some(Path::new("/sys/class/backlight").to_path_buf().join(path));
+            None => find_device(),
-        } else {
+        };
            for entry in WalkDir::new("/sys/class/backlight") {
                if let Ok(entry) = entry {
                    device_path = Some(entry.path().to_path_buf());
                }
            }
        }
        let mut dev = Backlight {
            device_path: device_path.expect("did not find backlight device"),
            cur: 0,
@@ -61,18 +73,15 @@ impl Backlight {
    }
    pub fn detect() -> bool {
-        for entry in WalkDir::new("/sys/class/backlight") {
+        find_device().is_some()
            if entry.is_ok() {
                return true;
            }
        }
        return false;
    }
    pub fn set(&mut self, brightness: f32) {
-        let val = (self.max as f32 * brightness) as u64;
+        let val = (self.max as f32 * brightness.clamp(0.0, 1.0)) as u64;
        let _ = write_file_as_u64(self.device_path.join("brightness").as_path(), val);
-        self.cur = read_file_as_u64(self.device_path.join("brightness").as_path()).unwrap();
+        if let Ok(cur) = read_file_as_u64(self.device_path.join("brightness").as_path()) {
            self.cur = cur;
        }
    }
 }
@@ -84,7 +93,7 @@ impl BarWidgetImpl for Backlight {
        self.dirty
    }
    fn value(&mut self) -> f32 {
-        if self.cur > self.max {
+        if self.max == 0 || self.cur > self.max {
            // what.
            return 1.0;
        }
@@ -97,9 +106,8 @@ impl BarWidgetImpl for Backlight {
    }
    fn click(&mut self, pos: f32, btn: PointerButton) {
        self.dirty = true;
-        match btn {
+        if let PointerButton::Left = btn {
-            PointerButton::Left => self.set(pos),
+            self.set(pos)
            _ => (),
        };
    }
 }
@@ -62,21 +62,13 @@ impl Widget for BarWidget {
        let val = self.inner_widget.value();
        let c = self.inner_widget.color();
-        draw_bar(
+        let bar_width = self.geometry.width.saturating_sub(bar_offset);
-            &mut view.offset((bar_offset, 0)),
+        if bar_width < 2 {
-            c,
+            return self.geometry;
-            self.geometry.width - bar_offset,
+        }
-            size,
+        draw_bar(&mut view.offset((bar_offset, 0)), c, bar_width, size, val).unwrap();
            val,
        )
        .unwrap();
-        draw_box(
+        draw_box(&mut view.offset((bar_offset, 0)), c, (bar_width, size)).unwrap();
            &mut view.offset((bar_offset, 0)),
            c,
            (self.geometry.width - bar_offset, size),
        )
        .unwrap();
        self.geometry
    }
@@ -87,7 +79,7 @@ impl Widget for BarWidget {
            x += geometry.width - w;
        }
        self.geometry = Geometry {
-            x: x,
+            x,
            y: geometry.y,
            width: w,
            height: self.size.ceil() as u32,
@@ -105,15 +97,12 @@ impl Widget for BarWidget {
    }
    fn event(&mut self, event: &Event) {
-        match event {
+        if let Event::PointerEvent(ev) = event {
            Event::PointerEvent(ev) => {
            let offset = 4 * self.size.ceil() as u32;
-                if ev.pos.0 >= offset {
+            if ev.pos.0 >= offset && self.geometry.width > offset {
                let val = (ev.pos.0 - offset) as f32 / (self.geometry.width - offset) as f32;
                self.inner_widget.click(val, ev.button);
            }
        }
            _ => (),
        }
    }
 }
@@ -6,8 +6,8 @@ use std::{
 };
 use dbus::blocking::{
    stdintf::org_freedesktop_dbus::{Properties, PropertiesPropertiesChanged},
    LocalConnection,
    stdintf::org_freedesktop_dbus::{Properties, PropertiesPropertiesChanged},
 };
 use crate::{
@@ -47,77 +47,87 @@ struct InnerBattery {
    dirty: bool,
 }
-fn get_battery_state() -> Result<UpowerBatteryState, Box<dyn Error>> {
+const DEVICE_PATH: &str = "/org/freedesktop/UPower/devices/DisplayDevice";
 const DEVICE_IFACE: &str = "org.freedesktop.UPower.Device";
 /// True if UPower reports a present battery. The DisplayDevice object exists
 /// even on machines without a battery, so checking for mere reachability
 /// (as before) made every desktop grow a battery widget.
 fn battery_present() -> Result<bool, Box<dyn Error>> {
    let conn = LocalConnection::new_system()?;
    let device_path = "/org/freedesktop/UPower/devices/DisplayDevice";
    let proxy = conn.with_proxy(
        "org.freedesktop.UPower",
-        device_path,
+        DEVICE_PATH,
        Duration::from_millis(500),
    );
-    let state: u32 = proxy.get("org.freedesktop.UPower.Device", "State")?;
+    let present: bool = proxy.get(DEVICE_IFACE, "IsPresent")?;
-    Ok(UpowerBatteryState::from_dbus(state as u64))
+    Ok(present)
 }
-fn start_monitor(inner: Arc<Mutex<InnerBattery>>, events: Arc<Mutex<Events>>) {
+fn monitor(
-    thread::Builder::new()
+    inner: Arc<Mutex<InnerBattery>>,
-        .name("battmon".to_string())
+    events: Arc<Mutex<Events>>,
-        .spawn(move || {
+) -> Result<(), Box<dyn Error>> {
-            let conn = LocalConnection::new_system().unwrap();
+    let conn = LocalConnection::new_system()?;
            let device_path = "/org/freedesktop/UPower/devices/DisplayDevice";
    let proxy = conn.with_proxy(
        "org.freedesktop.UPower",
-                device_path,
+        DEVICE_PATH,
        Duration::from_millis(500),
    );
-            let capacity: f64 = proxy
+    let capacity: f64 = proxy.get(DEVICE_IFACE, "Percentage")?;
-                .get("org.freedesktop.UPower.Device", "Percentage")
+    let state: u32 = proxy.get(DEVICE_IFACE, "State")?;
                .expect("unable to get property");
            let state: u32 = proxy
                .get("org.freedesktop.UPower.Device", "State")
                .expect("unable to get state");
    {
        let mut inner = inner.lock().unwrap();
        inner.value = capacity as f32 / 100.;
        inner.state = UpowerBatteryState::from_dbus(state as u64);
        inner.dirty = true;
    }
    events.lock().unwrap().add_event(Event::PowerUpdate);
-            proxy
+    proxy.match_signal(
-                .match_signal(
+        move |c: PropertiesPropertiesChanged, _: &LocalConnection, _: &dbus::Message| {
-                    move |c: PropertiesPropertiesChanged,
+            if c.interface_name != DEVICE_IFACE {
                          _: &LocalConnection,
                          _: &dbus::Message| {
                        if c.interface_name != "org.freedesktop.UPower.Device" {
                return true;
            }
            let mut inner = inner.lock().unwrap();
            for (key, value) in c.changed_properties {
                match key.as_str() {
                    "State" => {
-                                    inner.state =
+                        if let Some(v) = value.0.as_u64() {
-                                        UpowerBatteryState::from_dbus(value.0.as_u64().unwrap());
+                            inner.state = UpowerBatteryState::from_dbus(v);
                            inner.dirty = true;
-                                    let mut events = events.lock().unwrap();
+                            events.lock().unwrap().add_event(Event::PowerUpdate);
-                                    events.add_event(Event::PowerUpdate);
+                        }
                    }
                    "Percentage" => {
-                                    inner.value = value.0.as_f64().unwrap() as f32 / 100.;
+                        if let Some(v) = value.0.as_f64() {
                            inner.value = v as f32 / 100.;
                            inner.dirty = true;
-                                    let mut events = events.lock().unwrap();
+                            events.lock().unwrap().add_event(Event::PowerUpdate);
-                                    events.add_event(Event::PowerUpdate);
+                        }
                    }
                    _ => (),
                }
            }
            true
        },
-                )
+    )?;
                .unwrap();
    loop {
-                conn.process(Duration::from_millis(60000)).unwrap();
+        conn.process(Duration::from_millis(60000))?;
    }
 }
 fn start_monitor(inner: Arc<Mutex<InnerBattery>>, events: Arc<Mutex<Events>>) {
    thread::Builder::new()
        .name("battmon".to_string())
        .spawn(move || {
            // The release profile uses panic = "abort": a panic here would take
            // the whole dashboard down, so report and leave the bar at 0.
            if let Err(e) = monitor(inner, events) {
                eprintln!("wldash: battery monitor stopped: {}", e);
            }
        })
        .unwrap();
@@ -128,6 +138,8 @@ pub struct Battery {
 }
 impl Battery {
    // Wraps the impl in the generic BarWidget on purpose.
    #[allow(clippy::new_ret_no_self)]
    pub fn new(
        events: Arc<Mutex<Events>>,
        fm: &mut FontMap,
@@ -146,10 +158,7 @@ impl Battery {
    }
    pub fn detect() -> bool {
-        match get_battery_state() {
+        battery_present().unwrap_or(false)
            Ok(_) => true,
            Err(_) => false,
        }
    }
 }
@@ -69,7 +69,7 @@ impl Calendar {
    fn draw_month(
        &mut self,
        fonts: &mut FontMap,
-        mut view: &mut BufferView,
+        view: &mut BufferView,
        orig: NaiveDate,
        mut time: NaiveDate,
    ) {
@@ -100,7 +100,7 @@ impl Calendar {
                            + (self.size * DAY_FACTOR * 0.2).ceil() as u32,
                    )),
                    c,
-                    &wk_chr,
+                    wk_chr,
                )
                .unwrap();
        }
@@ -124,9 +124,7 @@ impl Calendar {
            12 => "December",
            _ => panic!("impossible value"),
        };
-        month_font
+        month_font.draw_text(view, Color::WHITE, month_str).unwrap();
            .draw_text(&mut view, Color::WHITE, month_str)
            .unwrap();
        //
        // Draw the year
@@ -199,7 +197,7 @@ impl Calendar {
    }
 }
-impl<'a> Widget for Calendar {
+impl Widget for Calendar {
    fn get_dirty(&self) -> bool {
        self.dirty
    }
@@ -209,12 +207,9 @@ impl<'a> Widget for Calendar {
    }
    fn event(&mut self, event: &Event) {
-        match event {
+        if let Event::NewMinute = event {
            Event::NewMinute => {
            self.dirty = true;
        }
            _ => (),
        }
    }
    fn draw(&mut self, fonts: &mut FontMap, view: &mut BufferView) -> Geometry {
@@ -299,9 +294,8 @@ impl<'a> Widget for Calendar {
        self.geometry = Geometry {
            x: geometry.x,
            y: geometry.y,
-            width: cal_width * self.shown_sections_x as u32
+            width: cal_width * self.shown_sections_x + cal_pad * (self.shown_sections_x - 1),
-                + cal_pad * (self.shown_sections_x as u32 - 1),
+            height: cal_height * self.shown_sections_y,
            height: cal_height * self.shown_sections_y as u32,
        };
        self.geometry
    }
@@ -323,7 +317,7 @@ impl<'a> Widget for Calendar {
                    y: 0,
                    width: 0,
                    height: 0,
-                }
+                };
            }
            x => x,
        };
@@ -335,7 +329,7 @@ impl<'a> Widget for Calendar {
                    y: 0,
                    width: 0,
                    height: 0,
-                }
+                };
            }
            y => y,
        };
@@ -344,8 +338,8 @@ impl<'a> Widget for Calendar {
        Geometry {
            x: 0,
            y: 0,
-            width: width,
+            width,
-            height: height,
+            height,
        }
    }
 }
@@ -19,7 +19,7 @@ pub struct Clock {
    colon_width: u32,
 }
-impl<'a> Clock {
+impl Clock {
    pub fn new(fm: &mut FontMap, font: &'static str, size: f32) -> Clock {
        fm.queue_font(font, size, "0123456789: ");
        Clock {
@@ -33,7 +33,7 @@ impl<'a> Clock {
    }
 }
-impl<'a> Widget for Clock {
+impl Widget for Clock {
    fn get_dirty(&self) -> bool {
        self.dirty
    }
@@ -43,12 +43,9 @@ impl<'a> Widget for Clock {
    }
    fn event(&mut self, event: &Event) {
-        match event {
+        if let Event::NewMinute = event {
            Event::NewMinute => {
            self.dirty = true;
        }
            _ => (),
        }
    }
    fn draw(&mut self, fonts: &mut FontMap, view: &mut BufferView) -> Geometry {
@@ -29,7 +29,7 @@ impl Date {
    }
 }
-impl<'a> Widget for Date {
+impl Widget for Date {
    fn get_dirty(&self) -> bool {
        self.dirty
    }
@@ -39,12 +39,9 @@ impl<'a> Widget for Date {
    }
    fn event(&mut self, event: &Event) {
-        match event {
+        if let Event::NewMinute = event {
            Event::NewMinute => {
            self.dirty = true;
        }
            _ => (),
        }
    }
    fn draw(&mut self, fonts: &mut FontMap, view: &mut BufferView) -> Geometry {
@@ -1,10 +1,10 @@
 use std::{
-    cmp::{max, min, Ordering},
+    cmp::{Ordering, max, min},
    collections::HashMap,
    default::Default,
-    fs::{read_to_string, File},
+    fs::{File, read_to_string},
    io::Write,
-    process::{exit, Command},
+    process::{Command, exit},
    sync::{Arc, Mutex},
    thread,
 };
@@ -14,18 +14,18 @@ use crate::{
    color::Color,
    event::{Event, Events, PointerButton, PointerEvent},
    fonts::FontMap,
-    keyboard::{keysyms, KeyEvent},
+    keyboard::{KeyEvent, keysyms},
    utils::{
-        desktop::{load_desktop_cache, load_desktop_files, write_desktop_cache, Desktop},
+        desktop::{Desktop, load_desktop_cache, load_desktop_files, write_desktop_cache},
        xdg,
    },
    widgets::{Geometry, Widget},
 };
 use fuzzy_matcher::skim::SkimMatcherV2;
 use fuzzy_matcher::FuzzyMatcher;
 use fuzzy_matcher::skim::SkimMatcherV2;
 use unicode_segmentation::UnicodeSegmentation;
-use wayland_client::{protocol::wl_keyboard, WEnum};
+use wayland_client::{WEnum, protocol::wl_keyboard};
 struct Matcher {
    matches: HashMap<Desktop, i64>,
@@ -96,13 +96,19 @@ impl Prompt {
        }
    }
    /// Length of the input in graphemes. The cursor is a grapheme index, not
    /// a byte offset, so this (and never `input.len()`) is the upper bound.
    fn len(&self) -> usize {
        self.input.graphemes(true).count()
    }
    fn move_cursor(&mut self, distance: isize) {
        let new_cursor = self.cursor as isize + distance;
        let len = self.len() as isize;
        if new_cursor < 0 {
            self.cursor = 0;
-            return;
+        } else if new_cursor > len {
-        } else if new_cursor > self.input.len() as isize {
+            self.cursor = len as usize;
            self.cursor = self.input.len()
        } else {
            self.cursor = new_cursor as usize;
        }
@@ -110,11 +116,11 @@ impl Prompt {
    fn set(&mut self, v: &str) {
        self.input = v.to_string();
-        self.cursor = self.input.len();
+        self.cursor = self.len();
    }
    fn append(&mut self, v: &str) {
-        if self.input.len() == 0 {
+        if self.input.is_empty() {
            match v {
                "!" => {
                    self.mode = PromptMode::Shell;
@@ -128,13 +134,14 @@ impl Prompt {
            }
        }
        let indices: Vec<(usize, &str)> = self.input.grapheme_indices(true).collect();
-        if self.cursor == indices.len() {
+        if self.cursor >= indices.len() {
-            self.input += &v;
+            self.cursor = indices.len();
            self.input += v;
        } else {
            let index_at = indices[self.cursor].0;
-            self.input.insert_str(index_at, &v);
+            self.input.insert_str(index_at, v);
        }
-        self.cursor += 1;
+        self.cursor += v.graphemes(true).count();
    }
    fn backspace(&mut self) {
@@ -168,6 +175,7 @@ impl Prompt {
    fn clear_right(&mut self) {
        let indices: Vec<(usize, &str)> = self.input.grapheme_indices(true).collect();
        if !indices.is_empty() {
            self.cursor = min(self.cursor, indices.len());
            self.input = indices[0..self.cursor]
                .iter()
                .fold("".into(), |acc, el| acc + el.1);
@@ -179,6 +187,7 @@ impl Prompt {
    fn clear_left(&mut self) {
        let indices: Vec<(usize, &str)> = self.input.grapheme_indices(true).collect();
        if !indices.is_empty() {
            self.cursor = min(self.cursor, indices.len());
            self.input = indices[self.cursor..indices.len()]
                .iter()
                .fold("".into(), |acc, el| acc + el.1);
@@ -193,11 +202,32 @@ impl Prompt {
    }
    fn end(&mut self) {
-        self.cursor = self.input.len();
+        self.cursor = self.len();
    }
 }
 /// Strip desktop-entry field codes (%f, %u, %i, %c, ...) from an Exec line and
 /// unescape `%%`. We never pass files/URLs, so the codes expand to nothing.
 fn strip_field_codes(exec: &str) -> String {
    let mut out = String::with_capacity(exec.len());
    let mut chars = exec.chars().peekable();
    while let Some(c) = chars.next() {
        if c != '%' {
            out.push(c);
            continue;
        }
        match chars.next() {
            Some('%') => out.push('%'),
            Some(_) => (),
            None => (),
        }
    }
    out
 }
 trait InterfaceWidget {
    /// Number of selectable rows (used to clamp the selection).
    fn rows(&self) -> usize;
    fn trigger(&mut self, intf: &mut InnerInterface);
    fn draw(
        &mut self,
@@ -241,7 +271,7 @@ impl Launcher {
        Launcher {
            next_token: None,
-            options: options,
+            options,
            matches: Vec::new(),
            launch_cmd,
        }
@@ -258,23 +288,26 @@ impl Launcher {
        } else {
            cmd.arg(cmdline);
        }
-        cmd.spawn().unwrap();
+        match cmd.spawn() {
-        exit(0);
+            Ok(_) => exit(0),
            Err(e) => {
                eprintln!("wldash: failed to launch {:?}: {}", cmdline, e);
                exit(1);
            }
        }
    }
 }
 impl InterfaceWidget for Launcher {
    fn rows(&self) -> usize {
        self.matches.len()
    }
    fn trigger(&mut self, intf: &mut InnerInterface) {
        if self.matches.len() > intf.selection {
            let d = &self.matches[intf.selection];
            if let Some(exec) = &d.exec {
-                let exec = exec
+                self.exec(&strip_field_codes(exec));
                    .replace("%f", "")
                    .replace("%F", "")
                    .replace("%u", "")
                    .replace("%U", "");
                self.exec(&exec);
            }
        }
    }
@@ -321,7 +354,7 @@ impl InterfaceWidget for Launcher {
            .auto_draw_text_with_cursor(
                &mut prompt_line,
                fg,
-                &format!("   {}", &intf.prompt.input),
+                &format!("   {}", intf.prompt.input),
                intf.prompt.cursor + 3,
            )
            .unwrap();
@@ -345,8 +378,9 @@ impl InterfaceWidget for Launcher {
                    .fuzzy_indices(&m.name.to_lowercase(), &intf.prompt.input.to_lowercase())
                    .unwrap_or((0, vec![]));
-                let mut colors = Vec::with_capacity(m.name.len());
+                let nchars = m.name.chars().count();
-                for pos in 0..m.name.len() {
+                let mut colors = Vec::with_capacity(nchars);
                for pos in 0..nchars {
                    if indices.contains(&pos) {
                        colors.push(Color::LIGHTORANGE);
                    } else {
@@ -394,12 +428,21 @@ impl Shell {
        if let Some(token) = &self.next_token {
            cmd.env("XDG_ACTIVATION_TOKEN", token);
        }
-        cmd.args(&args[1..]).spawn().unwrap();
+        match cmd.args(&args[1..]).spawn() {
-        exit(0);
+            Ok(_) => exit(0),
            Err(e) => {
                eprintln!("wldash: failed to run {:?}: {}", args, e);
                exit(1);
            }
        }
    }
 }
 impl InterfaceWidget for Shell {
    fn rows(&self) -> usize {
        1
    }
    fn trigger(&mut self, intf: &mut InnerInterface) {
        let args = vec![
            "/bin/sh".to_string(),
@@ -431,7 +474,7 @@ impl InterfaceWidget for Shell {
            .auto_draw_text_with_cursor(
                &mut prompt_line,
                fg,
-                &format!("   {}", &intf.prompt.input),
+                &format!("   {}", intf.prompt.input),
                intf.prompt.cursor + 3,
            )
            .unwrap();
@@ -488,13 +531,18 @@ impl Calc {
        let old = self.old.lock().unwrap();
        for (input, res) in old.iter() {
-            write!(f, "{}={}\n", input, res).unwrap();
+            writeln!(f, "{}={}", input, res).unwrap();
        }
        f.sync_data().unwrap();
    }
 }
 impl InterfaceWidget for Calc {
    fn rows(&self) -> usize {
        // The live result plus the history entries.
        self.old.lock().unwrap().len() + 1
    }
    fn trigger(&mut self, intf: &mut InnerInterface) {
        let mut old = self.old.lock().unwrap();
        if intf.selection == 0 {
@@ -519,10 +567,7 @@ impl InterfaceWidget for Calc {
            rcalc_lib::parse::eval(&intf.prompt.input, &mut rcalc_lib::parse::CalcState::new())
                .map(|x| format!("{}", x))
                .map_err(|x| format!("{}", x));
-        self.result = match res {
+        self.result = res.ok();
            Ok(v) => Some(v),
            Err(_) => None,
        };
    }
    fn draw(
@@ -545,7 +590,7 @@ impl InterfaceWidget for Calc {
        font.auto_draw_text_with_cursor(
            &mut prompt_line,
            fg,
-            &format!("   {} ", &intf.prompt.input),
+            &format!("   {} ", intf.prompt.input),
            intf.prompt.cursor + 3,
        )
        .unwrap();
@@ -641,7 +686,10 @@ impl Interface {
    fn pointer_input(&mut self, event: &PointerEvent) {
        if let PointerButton::Left = event.button {
            let line_height = self.inner.size.ceil() as u32;
-            let height = self.inner.geometry.height - line_height - 8;
+            if line_height == 0 {
                return;
            }
            let height = self.inner.geometry.height.saturating_sub(line_height + 8);
            let lines = height / line_height;
            let offset = height % line_height;
@@ -650,13 +698,18 @@ impl Interface {
            } else {
                return;
            };
-            self.inner.selection = (lines - pos / line_height - 1) as usize;
+            let row = pos / line_height;
            if row >= lines {
                // Click landed on the prompt line or below.
                return;
            }
            self.inner.selection = (lines - row - 1) as usize;
            self.inner.dirty = true;
        }
    }
    fn exit(&mut self) {
-        if self.inner.prompt.input.len() == 0 {
+        if self.inner.prompt.input.is_empty() {
            std::process::exit(0);
        }
@@ -712,8 +765,11 @@ impl Interface {
            keysyms::KEY_Left => self.inner.prompt.move_cursor(-1),
            keysyms::KEY_Right => self.inner.prompt.move_cursor(1),
            keysyms::KEY_Up => {
                let max = widget.rows().saturating_sub(1);
                if self.inner.selection < max {
                    self.inner.selection += 1;
                }
            }
            keysyms::KEY_Down => {
                if self.inner.selection > 0 {
                    self.inner.selection -= 1;
@@ -721,7 +777,7 @@ impl Interface {
            }
            _ => {
                if let Some(utf8) = &event.utf8 {
-                    self.inner.prompt.append(&utf8);
+                    self.inner.prompt.append(utf8);
                    self.inner.selection = 0;
                    widget.update(&self.inner);
                } else {
@@ -751,7 +807,7 @@ impl Widget for Interface {
    }
    fn geometry_update(&mut self, _fonts: &mut FontMap, geometry: &Geometry) -> Geometry {
-        self.inner.geometry = geometry.clone();
+        self.inner.geometry = *geometry;
        self.inner.geometry
    }
@@ -781,3 +837,56 @@ impl Widget for Interface {
        }
    }
 }
 #[cfg(test)]
 mod tests {
    use super::{Prompt, PromptMode, strip_field_codes};
    #[test]
    fn prompt_cursor_is_grapheme_based() {
        let mut p = Prompt::new();
        p.append("ø");
        p.append("å");
        assert_eq!(p.cursor, 2);
        p.end();
        assert_eq!(p.cursor, 2);
        // Used to index past the grapheme table and panic.
        p.append("a");
        assert_eq!(p.input, "øåa");
        p.move_cursor(-10);
        assert_eq!(p.cursor, 0);
        p.move_cursor(100);
        assert_eq!(p.cursor, 3);
        p.backspace();
        assert_eq!(p.input, "øå");
        p.home();
        p.delete();
        assert_eq!(p.input, "å");
        p.set("blå");
        assert_eq!(p.cursor, 3);
        p.move_cursor(-1);
        p.clear_right();
        assert_eq!(p.input, "bl");
        p.clear_left();
        assert_eq!(p.input, "");
        assert_eq!(p.cursor, 0);
    }
    #[test]
    fn prompt_prefix_switches_mode() {
        let mut p = Prompt::new();
        p.append("=");
        assert!(matches!(p.mode, PromptMode::Calc));
        assert_eq!(p.input, "");
        p.backspace();
        assert!(matches!(p.mode, PromptMode::Normal));
    }
    #[test]
    fn field_codes_are_stripped() {
        assert_eq!(strip_field_codes("firefox %u"), "firefox ");
        assert_eq!(strip_field_codes("app --icon %i %c %k"), "app --icon   ");
        assert_eq!(strip_field_codes("echo 100%% %F"), "echo 100% ");
        assert_eq!(strip_field_codes("plain"), "plain");
    }
 }
@@ -1,3 +1,6 @@
 // Constructors here deliberately return Box<dyn Layout> so configs compose.
 #![allow(clippy::new_ret_no_self)]
 use std::cmp::max;
 use crate::{fonts::FontMap, state::State, widgets::Geometry};
@@ -30,7 +33,7 @@ impl Layout for HorizontalLayout {
        geometry: &Geometry,
        state: &mut State,
    ) -> Geometry {
-        let mut geo = geometry.clone();
+        let mut geo = *geometry;
        let mut max_width = 0;
        let mut max_height = 0;
        for w in self.widgets.iter() {
@@ -79,7 +82,7 @@ impl Layout for VerticalLayout {
        geometry: &Geometry,
        state: &mut State,
    ) -> Geometry {
-        let mut geo = geometry.clone();
+        let mut geo = *geometry;
        let mut max_width = 0;
        let mut max_height = 0;
        for w in self.widgets.iter() {
@@ -159,10 +162,10 @@ impl Layout for InvertedHorizontalLayout {
        geometry: &Geometry,
        state: &mut State,
    ) -> Geometry {
-        let mut geo = geometry.clone();
+        let mut geo = *geometry;
        let mut max_height = 0;
        for w in self.widgets.iter() {
-            let mut temp_geo = geo.clone();
+            let mut temp_geo = geo;
            let temp_result = w.geometry_update(fonts, &temp_geo, state);
            temp_geo.x = geo.x + (geo.width - temp_result.width);
            let result = w.geometry_update(fonts, &temp_geo, state);
@@ -207,10 +210,10 @@ impl Layout for InvertedVerticalLayout {
        geometry: &Geometry,
        state: &mut State,
    ) -> Geometry {
-        let mut geo = geometry.clone();
+        let mut geo = *geometry;
        let mut max_width = 0;
        for w in self.widgets.iter() {
-            let mut temp_geo = geo.clone();
+            let mut temp_geo = geo;
            let temp_result = w.geometry_update(fonts, &temp_geo, state);
            temp_geo.y = geo.y + (geo.height - temp_result.height);
            let result = w.geometry_update(fonts, &temp_geo, state);
@@ -26,13 +26,13 @@ fn monitor(
    use libpulse_binding::{
        callbacks::ListResult,
        context::{
            subscribe::{Facility, InterestMaskSet},
            Context, FlagSet, State,
            subscribe::{Facility, InterestMaskSet},
        },
        mainloop::{
            self, api::Mainloop, events::io::FlagSet as IoFlagSet, standard::IterateResult,
        },
-        proplist::{properties, Proplist},
+        proplist::{Proplist, properties},
        volume::Volume,
    };
@@ -48,10 +48,17 @@ fn monitor(
    context.borrow_mut().connect(None, FlagSet::NOFLAGS, None)?;
    loop {
-        mainloop.iterate(false);
+        match mainloop.iterate(true) {
            IterateResult::Quit(_) | IterateResult::Err(_) => {
                return Err("pulseaudio mainloop quit while connecting".into());
            }
            _ => (),
        }
        match context.borrow().get_state() {
            State::Ready => break,
-            State::Failed | State::Terminated => panic!("damn"),
+            State::Failed | State::Terminated => {
                return Err("could not connect to pulseaudio".into());
            }
            _ => (),
        }
    }
@@ -60,15 +67,15 @@ fn monitor(
    let local_inner = inner.clone();
    let local_events = events.clone();
    context.borrow_mut().set_subscribe_callback(Some(Box::new(
-        move |facility, _operation, index| match facility {
+        move |facility, _operation, index| {
-            Some(Facility::Sink) => {
+            if let Some(Facility::Sink) = facility {
                let introspector = local_context.borrow_mut().introspect();
                let inner = local_inner.clone();
                let events = local_events.clone();
                introspector.get_sink_info_by_index(index, move |res| match res {
                    ListResult::End | ListResult::Error => (),
                    ListResult::Item(sink_info) => {
-                        if let Some(_) = &sink_info.name {
+                        if sink_info.name.is_some() {
                            let avg = sink_info.volume.avg().0 as f32 / Volume::NORMAL.0 as f32;
                            let mut inner = inner.lock().unwrap();
                            inner.volume = avg;
@@ -81,7 +88,6 @@ fn monitor(
                    }
                });
            }
            _ => (),
        },
    )));
@@ -94,7 +100,7 @@ fn monitor(
    introspector.get_sink_info_by_name("@DEFAULT_SINK@", move |res| match res {
        ListResult::End | ListResult::Error => (),
        ListResult::Item(sink_info) => {
-            if let Some(_) = &sink_info.name {
+            if sink_info.name.is_some() {
                let avg = sink_info.volume.avg().0 as f32 / Volume::NORMAL.0 as f32;
                let mut inner = local_inner.lock().unwrap();
                inner.volume = avg;
@@ -112,7 +118,7 @@ fn monitor(
    let local_context = context.clone();
    let local_inner = inner.clone();
    let event_source = mainloop.new_io_event(
-        pipe as i32,
+        pipe,
        IoFlagSet::INPUT,
        Box::new(move |_, _, _| {
            let mut buf = [0; 8];
@@ -120,15 +126,14 @@ fn monitor(
            let mut inner = local_inner.lock().unwrap();
            let mut introspector = local_context.borrow_mut().introspect();
-            match inner.last_click.take() {
+            // Clicks arriving before the first sink query finished have no
-                Some(Change::Volume(volume)) => {
+            // channel map to work with; drop them instead of panicking.
-                    // do something
+            match (inner.last_click.take(), inner.channel_volume) {
-                    let mut vol = inner.channel_volume.unwrap();
+                (Some(Change::Volume(volume)), Some(mut vol)) => {
                    vol.scale(Volume((volume * Volume::NORMAL.0 as f32).round() as u32));
                    introspector.set_sink_volume_by_name("@DEFAULT_SINK@", &vol, None);
                }
-                Some(Change::VolumeInc(value)) => {
+                (Some(Change::VolumeInc(value)), Some(mut vol)) => {
                    let mut vol = inner.channel_volume.unwrap();
                    // apply step to volumes
                    let step = (value * Volume::NORMAL.0 as f32).round() as i32;
                    if step > 0 {
@@ -141,10 +146,10 @@ fn monitor(
                    inner.channel_volume = Some(vol);
                    introspector.set_sink_volume_by_name("@DEFAULT_SINK@", &vol, None);
                }
-                Some(Change::ToggleMute) => {
+                (Some(Change::ToggleMute), _) => {
                    introspector.set_sink_mute_by_name("@DEFAULT_SINK@", !inner.mute, None);
                }
-                None => (),
+                _ => (),
            }
        }),
    );
@@ -165,7 +170,13 @@ fn monitor(
 fn start_monitor(events: Arc<Mutex<Events>>, inner: Arc<Mutex<InnerAudio>>, pipe: RawFd) {
    thread::Builder::new()
        .name("audiomon".to_string())
-        .spawn(move || monitor(events, inner, pipe).unwrap())
+        .spawn(move || {
            // panic = "abort" in release: a failed audio connection must not
            // kill the dashboard. The widget simply stays at 0.
            if let Err(e) = monitor(events, inner, pipe) {
                eprintln!("wldash: audio monitor stopped: {}", e);
            }
        })
        .unwrap();
 }
@@ -189,6 +200,8 @@ pub struct PulseAudio {
 }
 impl PulseAudio {
    // Wraps the impl in the generic BarWidget on purpose.
    #[allow(clippy::new_ret_no_self)]
    pub fn new(
        events: Arc<Mutex<Events>>,
        fm: &mut FontMap,
@@ -40,7 +40,7 @@ impl Geometry {
            x,
            y,
            width: max(self.width + self.x, other.width + other.x) - x,
-            height: max(self.height + self.y, other.height + other.height) - y,
+            height: max(self.height + self.y, other.height + other.y) - y,
        }
    }
@@ -64,3 +64,33 @@ pub trait Widget {
    fn draw(&mut self, fonts: &mut FontMap, view: &mut BufferView) -> Geometry;
    fn event(&mut self, _event: &Event) {}
 }
 #[cfg(test)]
 mod tests {
    use super::Geometry;
    #[test]
    fn expand_is_bounding_box() {
        let a = Geometry {
            x: 10,
            y: 20,
            width: 5,
            height: 5,
        };
        let b = Geometry {
            x: 0,
            y: 100,
            width: 2,
            height: 2,
        };
        let e = a.expand(b);
        assert_eq!((e.x, e.y), (0, 20));
        assert_eq!(e.x + e.width, 15);
        assert_eq!(e.y + e.height, 102);
        let e2 = b.expand(a);
        assert_eq!(
            (e2.x, e2.y, e2.width, e2.height),
            (e.x, e.y, e.width, e.height)
        );
    }
 }
Author	SHA1	Message	Date
Bendik Aagaard LynghaugandClaude Fable 5.1	03a3c681b0	packaging: PKGBUILD, changelog and tag-driven release workflow (0.4.0) Release / package (x86_64, /var/local/cargo-target/iris-cargo-home, bare, /usr/bin/sccache, /var/local/rustup, /var/local/cargo-target) (push) Successful in 1m12s Details Release / package (aarch64, , aarch64, , , ) (push) Successful in 2m31s Details Same shape as uhhm/gdo: a v* tag runs makepkg on the x86_64 (ergo, "bare") and aarch64 (klokka) runners, uploads to the [uhhm] Arch registry under namespace bl, and creates a release with the changelog section as notes. The tag must agree with PKGBUILD's pkgver and Cargo.toml's version. Without a REGISTRY_TOKEN secret the publish step warns and skips so the build is still verified. Version jumps to 0.4.0 because upstream already tagged v0.2.1 and v0.3.0 on this history before the rewrite reset Cargo.toml to 0.2.0. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-10-03 09:28:22 +00:00
Bendik Aagaard LynghaugandClaude Fable 5.1	1c6a536026	clippy: clean up all warnings Mostly `cargo clippy --fix`: needless borrows, redundant field names, match -> if let, io::Error::other, Option::filter/map, let chains, c"" literals. By hand: drop unused impl lifetimes, a type alias for the font preload map, Iterator::find in next_buffer, contains_key, and allow new_ret_no_self where constructors intentionally return the boxed/generic wrapper type. No functional change; tests and release build unchanged. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-10-03 09:20:25 +00:00
Bendik Aagaard LynghaugandClaude Fable 5.1	42ffe9c492	cargo fmt Pure formatting, no functional change. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-10-03 09:16:15 +00:00
Bendik Aagaard LynghaugandClaude Fable 5.1	856f8d8bf4	readme: document the fork and /etc/wldash/config.yml precedence Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-10-03 09:15:57 +00:00
Bendik Aagaard LynghaugandClaude Fable 5.1	eea3a78140	main: clear error messages and exit codes instead of panics Missing/invalid config, unwritable config target, failed Wayland connect and bad arguments now print one line to stderr and exit 1 rather than panicking with "uh" or a serde backtrace. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-10-03 09:15:56 +00:00
Bendik Aagaard LynghaugandClaude Fable 5.1	8c319cffc6	keyboard/state: handle repeat rate 0, let widgets see Escape - wl_keyboard.repeat_info with rate 0 means "no repeat"; we divided by it. - an unknown keymap format hit unreachable!() instead of being ignored. - raw keycode 1 (Escape) returned before widgets were dispatched, so the launcher's Escape handler (which saves the prompt for Ctrl+R) never ran. Dispatch first, then fall back to quitting. - always lay out on the first layer-surface configure, even when the compositor hands us exactly the placeholder dimensions. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-10-03 09:15:56 +00:00
Bendik Aagaard LynghaugandClaude Fable 5.1	450a20bf63	widget: fix Geometry::expand using other.height twice The bounding-box height was computed from other.height + other.height instead of other.height + other.y, so the combined damage rectangle sent to the compositor was wrong whenever a widget's drawn area changed. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-10-03 09:15:55 +00:00
Bendik Aagaard LynghaugandClaude Fable 5.1	6af81b587c	buffer: switch to memmap2, destroy shm pools, never underflow refcounts memmap 0.7 is unmaintained (RUSTSEC-2020-0077); memmap2 is a drop-in replacement. Drop the unused shlex dependency. Each resize created a new wl_shm_pool that was never destroyed; keep the pool on the buffer and destroy it with it. A wl_buffer.release for a buffer we didn't consider acquired used to underflow refcnt and wedge rendering. Fix the lifetime-elision warnings while here. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-10-03 09:15:54 +00:00
Bendik Aagaard LynghaugandClaude Fable 5.1	c033335912	widgets: stop aborting on machines without backlight/battery/pulseaudio The release profile builds with panic = "abort", so a panic in any helper thread took the whole dashboard down: - backlight: WalkDir yields /sys/class/backlight itself, so detect() was always true and new() picked the class dir as the device, then panicked reading brightness. Use min_depth(1) and tolerate read errors. - battery: detect() only checked that UPower's DisplayDevice answered, which it does on every machine; use IsPresent. The monitor thread now returns an error instead of unwrapping, and publishes its first reading. - pulseaudio: a failed connection panicked ("damn"); clicks before the first sink query unwrapped a None channel map. Both are now handled, and the connect loop no longer busy-spins. - bar widget: don't underflow when narrower than the label column. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-10-03 09:15:54 +00:00
Bendik Aagaard LynghaugandClaude Fable 5.1	01af00b5ea	desktop: hash entries the same way they compare, only parse *.desktop Desktop derived Hash over every field but PartialEq compared only the name, violating the Hash/Eq contract the launcher's HashMap relies on (clippy denies this by default, so `cargo clippy` failed to build). Also skip directories and files without a .desktop extension (mimeinfo cache, .directory files, ...) and stop unwrapping non-UTF-8 paths. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-10-03 09:15:53 +00:00
Bendik Aagaard LynghaugandClaude Fable 5.1	2bed8b7fac	launcher: make the prompt cursor consistently grapheme-based set(), end() and move_cursor() used the byte length of the input as the cursor bound while append/backspace/delete/clear_* index a grapheme table. Any non-ASCII input (æøå, emoji) followed by End or typing past the end indexed out of bounds and, with panic = "abort" in release, killed wldash. While here: - clamp Up so the selection can't run past the last row (every widget now reports its row count), and make mouse selection underflow-safe - strip all desktop-entry field codes from Exec (%i %c %k ... and %% -> %), not just %f/%F/%u/%U - report a failed spawn instead of panicking - size the highlight colour table by chars, matching the drawing code Adds unit tests for the prompt and the field-code stripping. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-10-03 09:15:53 +00:00
Bendik Aagaard LynghaugandClaude Opus 4.8	1367bd8591	config: prefer machine-local /etc/wldash/config.yml when present On a shared (NFS-roamed) home, ~/.config/wldash/config.yml is identical on every machine. Prefer a host-specific /etc/wldash/config.yml when it exists so each machine can keep its own layout without conflicting; --config still overrides both. Enables the 'factor host-specific config to /etc' pattern for shared-home fleets. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-09-16 14:16:22 +02:00
Alejandro Visiedo	1156b3503a	fix: ensure dirs exist Ensure ~/.config/wldash and ~/.cache/wldash exist. Provide hints when no configuration exists. Signed-off-by: Alejandro Visiedo <alejandro.visiedo@gmail.com>	2025-05-08 12:59:41 +02:00
Kenny Levinsen	d80a64444f	cargo: Update lock	2025-04-08 11:51:15 +02:00
Kenny Levinsen	456d61de01	cargo: Set binary name back to wldash During v2 development, the name was temporarily set to wldash2. Set it back to wldash so that things work.	2025-03-20 16:57:58 +01:00
Kenny Levinsen	ab2655556f	readme: Make note of rewrite	2025-02-27 17:42:09 +01:00
Kenny Levinsen	f0331e65b1	cargo: Bump to 2024 edition	2025-02-27 17:41:08 +01:00
Kenny Levinsen	25c7322c4b	cargo: Bump version to 0.2	2025-02-27 17:40:56 +01:00
Kenny Levinsen	7af5c34856	readme: Update for v2	2025-02-27 17:39:49 +01:00
Kenny Levinsen	e8def40fae	cargo: Make fontconfig a default feature	2025-02-27 17:39:40 +01:00