desktop: Unescape backslashes

The desktop spec applies escaping to string values. Perform a primitive
unescape.

.gitea/workflows/release.yml

@@ -1,114 +0,0 @@
-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"

CHANGELOG.md

@@ -1,16 +0,0 @@
-# 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.

Cargo.lock

@@ -462,6 +462,16 @@ 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"
@@ -799,6 +809,12 @@ 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"
@@ -1265,7 +1281,7 @@ checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
 
 [[package]]
 name = "wldash"
-version = "0.4.0"
+version = "0.2.0"
 dependencies = [
  "calloop",
  "chrono",
@@ -1273,12 +1289,13 @@ dependencies = [
  "fontconfig",
  "fuzzy-matcher",
  "libpulse-binding",
- "memmap2",
+ "memmap",
  "nix 0.26.4",
  "rcalc_lib",
  "rusttype",
  "serde",
  "serde_yaml",
+ "shlex",
  "simd-json",
  "unicode-segmentation",
  "walkdir",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wldash"
-version = "0.4.0"
+version = "0.2.0"
 edition = "2024"
 
 [profile.release]
@@ -16,7 +16,7 @@ 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
-memmap2 = "0.9"
+memmap = "0.7"
 fontconfig = { version = "0.8.0", optional = true }
 rusttype = "0.9"
 # fontdue = "0.7"
@@ -27,6 +27,7 @@ walkdir = "2.4"
 
 unicode-segmentation = "1.10"
 fuzzy-matcher = "0.3"
+shlex = "1.3"
 
 xkbcommon = { version = "0.8", features = ["wayland"] }
 

PKGBUILD

@@ -1,40 +0,0 @@
-# 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"
-}

README.md

@@ -10,23 +10,14 @@ Consider this alpha-quality: While it works, *everything* is subject to change w
 
 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://project.uhhm.no/bl/wldash`
+1. Checkout: `git clone https://github.com/kennylevinsen/wldash`
 2. Build: `cargo build --release`
 3. Put somewhere: `cp target/release/wldash /usr/local/bin/wldash`
 4. Run: `wldash`
 
-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.
+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.yaml`).
 
 To regenerate the desktop file cache, run `wldash --desktop-refresh`.
 

src/buffer.rs

@@ -1,4 +1,5 @@
 use std::{
+    ffi::CStr,
     fs::File,
     io,
     os::unix::io::{FromRawFd, RawFd},
@@ -15,11 +16,11 @@ use nix::{
     unistd,
 };
 
-use memmap2::MmapMut;
+use memmap::MmapMut;
 
 use wayland_client::{
-    Dispatch, QueueHandle,
     protocol::{wl_buffer, wl_shm, wl_shm_pool},
+    Dispatch, QueueHandle,
 };
 
 use crate::color::Color;
@@ -29,7 +30,10 @@ fn create_shm_fd() -> io::Result<RawFd> {
     // Only try memfd on linux
     #[cfg(target_os = "linux")]
     loop {
-        match memfd::memfd_create(c"wldash", memfd::MemFdCreateFlag::MFD_CLOEXEC) {
+        match memfd::memfd_create(
+            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,
@@ -74,13 +78,11 @@ 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>,
 }
 
@@ -92,6 +94,7 @@ 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,
@@ -99,16 +102,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 mmap = unsafe { MmapMut::map_mut(&file)? };
-        let buffer = pool.create_buffer(0, width, height, stride, format, qh, ());
+        let pool = shm.create_pool(mem_fd, height * stride, &qh, ());
+        let mmap = unsafe { MmapMut::map_mut(&file).unwrap() };
+        let buffer = pool.create_buffer(0, width, height, stride, format, &qh, ());
 
         Ok(ShmBuffer {
             refcnt: 0,
             file,
             mmap,
-            pool,
             buffer,
+            id,
             last_damage: Vec::new(),
         })
     }
@@ -118,33 +121,37 @@ impl ShmBuffer {
     }
 
     pub fn release(&mut self) {
-        // 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);
+        self.refcnt -= 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.pool.destroy();
+            buf.buffer.destroy()
         }
         self.buffers.clear()
     }
 
     pub fn next_buffer(&mut self) -> Option<&mut ShmBuffer> {
-        self.buffers.iter_mut().find(|buf| buf.refcnt == 0)
+        for buf in self.buffers.iter_mut() {
+            if buf.refcnt == 0 {
+                return Some(buf);
+            }
+        }
+        None
     }
 
     pub fn add_buffer<D>(
@@ -155,15 +162,18 @@ impl BufferManager {
     ) where
         D: Dispatch<wl_shm_pool::WlShmPool, ()> + Dispatch<wl_buffer::WlBuffer, ()> + 'static,
     {
-        let buf = ShmBuffer::new(
+        let mut 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);
     }
 }
@@ -175,7 +185,7 @@ pub struct BufferView<'a> {
 }
 
 impl<'a> BufferView<'a> {
-    pub fn new(buf: &'a mut MmapMut, dimensions: (u32, u32)) -> BufferView<'a> {
+    pub fn new(buf: &'a mut MmapMut, dimensions: (u32, u32)) -> BufferView {
         let view = unsafe {
             std::slice::from_raw_parts_mut(
                 buf.as_mut_ptr() as *mut u32,
@@ -198,7 +208,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
@@ -222,11 +232,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!(

src/config.rs

@@ -6,7 +6,7 @@ use std::sync::{Arc, Mutex};
 
 use crate::{
     event::Events,
-    fonts::{FontMap, find_font},
+    fonts::{find_font, FontMap},
     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>>,
-        fm: &mut FontMap,
+        mut 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(
-                fm,
+                &mut fm,
                 leak_or_default(font, "sans"),
                 font_size,
             ))),
             Widget::Date { font, font_size } => v.push(Box::new(Date::new(
-                fm,
+                &mut fm,
                 leak_or_default(font, "sans"),
                 font_size,
             ))),
@@ -317,7 +317,7 @@ impl Widget {
                 sections_x,
                 sections_y,
             } => v.push(Box::new(Calendar::new(
-                fm,
+                &mut 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(),
-                fm,
+                &mut fm,
                 leak_or_default(font, "sans"),
                 font_size,
                 launch_cmd,
             ))),
             Widget::Battery { font, font_size } => v.push(Box::new(Battery::new(
                 events.clone(),
-                fm,
+                &mut 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),
-                fm,
+                &mut fm,
                 leak_or_default(font, "sans"),
                 font_size,
             ))),
             Widget::PulseAudio { font, font_size } => v.push(Box::new(PulseAudio::new(
                 events.clone(),
-                fm,
+                &mut fm,
                 Box::leak(font.unwrap_or_else(|| "sans".to_string()).into_boxed_str()),
                 font_size,
             ))),

src/draw.rs

@@ -1,7 +1,7 @@
 use crate::buffer::BufferView;
 use crate::{color::Color, fonts::FontRef};
 
-use rusttype::{Scale, point};
+use rusttype::{point, Scale};
 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<'a> {
+    pub fn new(font: FontRef<'a>, size: f32) -> Font {
         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.contains_key(&ch) {
+            if self.glyphs.get(&ch).is_none() {
                 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::other(format!(
-                        "glyph for {:} not in cache",
-                        ch
-                    )));
+                    return Err(::std::io::Error::new(
+                        ::std::io::ErrorKind::Other,
+                        format!("glyph for {:} not in cache", 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::other(format!(
-                        "glyph for {:} not in cache",
-                        ch
-                    )));
+                    return Err(::std::io::Error::new(
+                        ::std::io::ErrorKind::Other,
+                        format!("glyph for {:} not in cache", 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::other(format!(
-                        "glyph for {:} not in cache",
-                        ch
-                    )));
+                    return Err(::std::io::Error::new(
+                        ::std::io::ErrorKind::Other,
+                        format!("glyph for {:} not in cache", 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::other(format!(
-                        "glyph for {:} not in cache",
-                        ch
-                    )));
+                    return Err(::std::io::Error::new(
+                        ::std::io::ErrorKind::Other,
+                        format!("glyph for {:} not in cache", 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::other(format!(
-                        "glyph for {:} not in cache",
-                        ch
-                    )));
+                    return Err(::std::io::Error::new(
+                        ::std::io::ErrorKind::Other,
+                        format!("glyph for {:} not in cache", ch),
+                    ))
                 }
             };
             glyphs.push(glyph);

src/event.rs

@@ -56,6 +56,6 @@ impl Events {
 
     pub fn flush(&mut self) -> Vec<Event> {
         self.dirty = false;
-        std::mem::take(&mut self.events)
+        self.events.drain(..).collect()
     }
 }

src/fonts.rs

@@ -70,13 +70,10 @@ 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: RequiredFonts,
+    required_fonts: HashMap<&'static str, (&'static str, Vec<(f32, &'static str)>)>,
 }
 
 impl FontMap {

src/keyboard/mod.rs

@@ -12,9 +12,12 @@
 //! calloop event loop. Not doing so will prevent key repetition to work
 //! (but the rest of the functionnality will not be affected).
 
-use std::{default::Default, os::unix::io::OwnedFd};
+use std::{
+    default::Default,
+    os::unix::io::{AsRawFd, OwnedFd},
+};
 
-use wayland_client::{WEnum, protocol::wl_keyboard};
+use wayland_client::{protocol::wl_keyboard, WEnum};
 use xkbcommon::xkb;
 
 pub use xkbcommon::xkb::keysyms;
@@ -28,7 +31,6 @@ 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>,
@@ -44,7 +46,7 @@ pub struct KeymapDescription {
 
 impl KeymapDescription {
     fn new(fd: OwnedFd, size: u32) -> KeymapDescription {
-        KeymapDescription { fd, size }
+        KeymapDescription { fd: fd, size: size }
     }
 }
 
@@ -75,9 +77,7 @@ impl Keyboard {
             WEnum::Value(wl_keyboard::KeymapFormat::NoKeymap) => {
                 // TODO: how to handle this (hopefully never occuring) case?
             }
-            // Unknown format from a newer protocol version: ignore rather than
-            // abort the whole process.
-            _ => (),
+            _ => unreachable!(),
         }
     }
 

src/keyboard/repeat.rs

@@ -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::{WEnum, protocol::wl_keyboard};
+use wayland_client::{protocol::wl_keyboard, WEnum};
 
 use super::KeyEvent;
 
@@ -89,18 +89,11 @@ 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;
-                            if key.is_some() {
-                                timer.set_deadline(now + *delay);
-                            }
+                        *rate = Duration::from_micros(1_000_000 / new_rate as u64);
+                        *delay = Duration::from_millis(new_delay as u64);
+                        *disabled = false;
+                        if key.is_some() {
+                            timer.set_deadline(now + *delay);
                         }
                     }
                 },
@@ -136,9 +129,7 @@ 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 {

src/keyboard/state.rs

@@ -81,15 +81,17 @@ impl KbState {
     }
 
     pub(crate) fn compose_feed(&mut self, keysym: u32) -> Option<xkb::compose::FeedResult> {
-        self.xkb_compose_state
-            .as_mut()
-            .map(|compose_state| compose_state.feed(xkb::Keysym::new(keysym)))
+        match &mut self.xkb_compose_state {
+            Some(compose_state) => Some(compose_state.feed(xkb::Keysym::new(keysym))),
+            None => None,
+        }
     }
 
     pub(crate) fn compose_status(&mut self) -> Option<xkb::compose::Status> {
-        self.xkb_compose_state
-            .as_mut()
-            .map(|compose_state| compose_state.status())
+        match &mut self.xkb_compose_state {
+            Some(compose_state) => Some(compose_state.status()),
+            None => None,
+        }
     }
 
     pub(crate) fn compose_get_utf8(&mut self) -> Option<String> {
@@ -128,11 +130,11 @@ impl KbState {
 
     pub(crate) fn init_compose(&mut self) {
         let locale = env::var_os("LC_ALL")
-            .filter(|v| !v.is_empty())
+            .and_then(|v| if v.is_empty() { None } else { Some(v) })
             .or_else(|| env::var_os("LC_CTYPE"))
-            .filter(|v| !v.is_empty())
+            .and_then(|v| if v.is_empty() { None } else { Some(v) })
             .or_else(|| env::var_os("LANG"))
-            .filter(|v| !v.is_empty())
+            .and_then(|v| if v.is_empty() { None } else { Some(v) })
             .unwrap_or_else(|| "C".into());
 
         let compose_table = match xkb::compose::Table::new_from_locale(

src/main.rs

@@ -12,8 +12,8 @@ mod widgets;
 use wayland_client::{Connection, QueueHandle, WaylandSource};
 
 use calloop::{
-    EventLoop,
     timer::{TimeoutAction, Timer},
+    EventLoop,
 };
 use chrono::{Duration, Local, Timelike};
 
@@ -30,11 +30,10 @@ use utils::{
 use widgets::{Geometry, Widget};
 
 use std::{
-    env, fs,
+    env,
     fs::File,
     io::{BufRead, BufReader, Write},
     os::unix::net::{UnixListener, UnixStream},
-    path::Path,
     rc::Rc,
     thread,
 };
@@ -46,8 +45,7 @@ usage: wldash [OPTIONS]
 
 OPTIONS:
   --config CONFIG_FILE                     use the specified config file
-                                           (/etc/wldash/config.yml if present,
-                                           else ~/.config/wldash/config.yml)
+                                           (~/.config/wldash/config.yml by default)
   --write-default-config [v1|v2|toplevel]  generate and write a new config file
                                            (v2 by default)
   --desktop-refresh                        refresh desktop file cache
@@ -55,50 +53,18 @@ 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();
 
-    create_required_directories();
-
-    let mut config_file = default_config_file();
+    let mut config_file = format!("{}/wldash/config.yml", xdg::config_folder());
 
     loop {
         match args.next() {
             Some(ref s) if s == "--config" => match args.next() {
                 Some(ref s) => config_file = s.clone(),
-                None => die("missing argument to --config".to_string()),
+                None => panic!("missing argument to --config"),
             },
             Some(ref s) if s == "--write-default-config" => {
                 let config = match args.next() {
@@ -106,23 +72,17 @@ 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) => die(format!("unknown argument to --write-default-config: {}", s)),
+                    Some(s) => panic!("unknown argument: {}", s),
                 };
-                match File::create(&config_file) {
-                    Ok(f) => {
-                        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)),
+                match File::create(config_file) {
+                    Ok(f) => serde_yaml::to_writer(f, &config).unwrap(),
+                    Err(_) => panic!("uh"),
                 }
                 std::process::exit(0);
             }
             Some(ref s) if s == "--desktop-refresh" => {
                 let v = load_desktop_files();
-                if let Err(e) = write_desktop_cache(&v) {
-                    die(format!("could not write desktop cache: {}", e));
-                }
+                write_desktop_cache(&v).unwrap();
                 std::process::exit(0);
             }
             Some(ref s) if s == "--help" => {
@@ -137,10 +97,7 @@ fn main() {
         }
     }
 
-    let conn = match Connection::connect_to_env() {
-        Ok(c) => c,
-        Err(e) => die(format!("could not connect to the Wayland display: {}", e)),
-    };
+    let conn = Connection::connect_to_env().unwrap();
 
     let event_queue = conn.new_event_queue();
     let qhandle: QueueHandle<State> = event_queue.handle();
@@ -159,7 +116,7 @@ fn main() {
     handle
         .insert_source(
             WaylandSource::new(event_queue).expect("Could not create WaylandSource!"),
-            |_event, queue, state| queue.dispatch_pending(state),
+            |_event, queue, mut state| queue.dispatch_pending(&mut state),
         )
         .expect("Failed to insert event source!");
 
@@ -216,15 +173,9 @@ fn main() {
 
     let mut fm = FontMap::new();
 
-    let config: Config = match File::open(&config_file) {
-        Ok(f) => match serde_yaml::from_reader(f) {
-            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
-        )),
+    let config: Config = match File::open(config_file) {
+        Ok(f) => serde_yaml::from_reader(f).unwrap(),
+        Err(_) => panic!("configuration file missing"),
     };
 
     if let Some(true) = config.server {
@@ -239,20 +190,23 @@ fn main() {
             .spawn(move || {
                 let listener = UnixListener::bind(socket_path.clone()).unwrap();
                 loop {
-                    if let Ok((stream, _)) = listener.accept() {
-                        let _ = thread::Builder::new().name("ipc_client".to_string()).spawn(
-                            move || {
-                                let r = BufReader::new(stream);
-                                for line in r.lines() {
-                                    match line {
-                                        Ok(ref cmd) if cmd == "kill" => {
-                                            std::process::exit(0);
+                    match listener.accept() {
+                        Ok((stream, _)) => {
+                            let _ = thread::Builder::new().name("ipc_client".to_string()).spawn(
+                                move || {
+                                    let r = BufReader::new(stream);
+                                    for line in r.lines() {
+                                        match line {
+                                            Ok(ref cmd) if cmd == "kill" => {
+                                                std::process::exit(0);
+                                            }
+                                            _ => {}
                                         }
-                                        _ => {}
                                     }
-                                }
-                            },
-                        );
+                                },
+                            );
+                        }
+                        _ => (),
                     }
                 }
             });
@@ -307,7 +261,7 @@ fn main() {
         }
 
         let mut force = false;
-        if state.bufmgr.buffers.is_empty() {
+        if state.bufmgr.buffers.len() == 0 {
             state.add_buffer(&qhandle);
             force = true;
         }
@@ -331,7 +285,7 @@ fn main() {
             }
         };
 
-        if buf.last_damage.is_empty() {
+        if buf.last_damage.len() == 0 {
             for _ in 0..state.widgets.len() {
                 buf.last_damage.push(Geometry::new());
             }

src/state.rs

@@ -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,16 +133,17 @@ impl State {
             Ok(token) => token,
             Err(_) => return,
         };
-        if let (Some(surface), Some(activation)) = (
+        match (
             &self.main_surface.wl_surface,
             &self.protocols.xdg_activation,
         ) {
-            activation.activate(key, surface);
-            let activation_token = activation.get_activation_token(qh, ());
-            activation_token.commit();
-            unsafe {
-                env::remove_var("XDG_ACTIVATION_TOKEN");
+            (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"); }
             }
+            _ => (),
         }
     }
 }
@@ -330,8 +331,9 @@ impl Dispatch<wl_callback::WlCallback, ()> for State {
         _: &Connection,
         _: &QueueHandle<Self>,
     ) {
-        if let wl_callback::Event::Done { callback_data: _ } = event {
-            state.ready = true
+        match event {
+            wl_callback::Event::Done { callback_data: _ } => state.ready = true,
+            _ => {}
         }
     }
 }
@@ -459,15 +461,12 @@ 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);
 
-                // Always lay out on the first configure, even if the
-                // compositor happens to hand us our placeholder dimensions.
-                if !first_configure && state.dimensions == dim {
+                if state.configured && state.dimensions == dim {
                     return;
                 }
                 state.bufmgr.clear_buffers();
@@ -479,8 +478,8 @@ impl Dispatch<zwlr_layer_surface_v1::ZwlrLayerSurfaceV1, ()> for State {
                     &Geometry {
                         x: 0,
                         y: 0,
-                        width,
-                        height,
+                        width: width as u32,
+                        height: height as u32,
                     },
                     state,
                 );
@@ -657,26 +656,24 @@ 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);
                 }
-                // Raw keycode 1 is KEY_ESC: fall back to quitting even when no
-                // 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();
+                if repeats {
+                    if let Event::KeyEvent(k) = ev {
+                        state
+                            .keyrepeat_sender
+                            .send(RepeatMessage::KeyEvent(k))
+                            .unwrap();
+                    }
                 }
                 state.dirty = true;
             }
@@ -736,8 +733,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, .. } => {
-                if let Some((x, y)) = state.pointer {
+            wl_pointer::Event::Axis { axis, value, .. } => match state.pointer {
+                Some((x, y)) => {
                     let axis = match axis {
                         WEnum::Value(wl_pointer::Axis::VerticalScroll) => {
                             PointerButton::ScrollVertical(value)
@@ -752,22 +749,24 @@ 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 { button: axis, pos });
+                            let ev = Event::PointerEvent(PointerEvent {
+                                button: axis,
+                                pos: pos,
+                            });
                             widget.event(&ev);
                             state.dirty = true;
                             break;
                         }
                     }
                 }
-            }
+                _ => (),
+            },
             wl_pointer::Event::Button {
                 button,
                 state: button_state,
                 ..
-            } => {
-                if let (button, WEnum::Value(wl_pointer::ButtonState::Pressed), Some((x, y))) =
-                    (button, button_state, state.pointer)
-                {
+            } => match (button, button_state, state.pointer) {
+                (button, WEnum::Value(wl_pointer::ButtonState::Pressed), Some((x, y))) => {
                     let button = match button {
                         BTN_LEFT => PointerButton::Left,
                         BTN_RIGHT => PointerButton::Right,
@@ -779,14 +778,18 @@ 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 { button, pos });
+                            let ev = Event::PointerEvent(PointerEvent {
+                                button: button,
+                                pos: pos,
+                            });
                             widget.event(&ev);
                             state.dirty = true;
                             break;
                         }
                     }
                 }
-            }
+                _ => (),
+            },
             _ => (),
         }
     }
@@ -849,11 +852,14 @@ impl Dispatch<xdg_activation_token_v1::XdgActivationTokenV1, ()> for State {
         _: &Connection,
         _: &QueueHandle<Self>,
     ) {
-        if let xdg_activation_token_v1::Event::Done { token } = event {
-            let ev = Event::TokenUpdate(token);
-            for widget in state.widgets.iter_mut() {
-                widget.event(&ev);
+        match event {
+            xdg_activation_token_v1::Event::Done { token } => {
+                let ev = Event::TokenUpdate(token);
+                for widget in state.widgets.iter_mut() {
+                    widget.event(&ev);
+                }
             }
+            _ => (),
         }
     }
 }

src/utils/desktop.rs

@@ -2,10 +2,8 @@ use std::{
     cmp::Ordering,
     collections::HashSet,
     error::Error,
-    fs::{File, read_to_string},
-    hash::{Hash, Hasher},
+    fs::{read_to_string, File},
     io::{Error as io_error, ErrorKind},
-    path::Path,
 };
 
 use serde::{self, Deserialize, Serialize};
@@ -14,7 +12,7 @@ use walkdir::WalkDir;
 
 use crate::utils::{inish, xdg};
 
-#[derive(Serialize, Deserialize, Clone, Debug, Eq)]
+#[derive(Serialize, Deserialize, Clone, Debug, Eq, Hash)]
 #[serde(rename_all = "snake_case")]
 pub struct Desktop {
     pub entry_type: String,
@@ -28,7 +26,7 @@ pub struct Desktop {
 }
 
 impl Desktop {
-    fn parse(f: &Path) -> Result<Desktop, Box<dyn Error>> {
+    fn parse(f: &str) -> Result<Desktop, Box<dyn Error>> {
         let s = read_to_string(f)?;
         let config = inish::parse(&s)?;
         match config.get("Desktop Entry") {
@@ -45,10 +43,10 @@ impl Desktop {
                     .map(|x| {
                         x.split(';')
                             .map(|y| y.trim().to_string())
-                            .filter(|z| !z.is_empty())
+                            .filter(|z| z != "")
                             .collect()
                     })
-                    .unwrap_or_else(std::vec::Vec::new),
+                    .unwrap_or_else(|| vec![]),
             }),
             None => Err(Box::new(io_error::new(
                 ErrorKind::NotFound,
@@ -76,13 +74,6 @@ 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()),
@@ -104,18 +95,9 @@ 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))
-            .into_iter()
-            .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()) {
+        for entry in WalkDir::new(format!("{}/applications", dir)) {
+            if let Ok(entry) = entry {
+                if let Ok(d) = Desktop::parse(entry.path().to_str().unwrap()) {
                     if d.hidden
                         || d.no_display
                         || (d.entry_type != "Application" && d.entry_type != "Link")

src/utils/inish.rs

@@ -1,6 +1,6 @@
 use std::{collections::HashMap, error::Error};
 
-fn parse_field(line: &str) -> Result<(&str, &str), Box<dyn Error>> {
+fn parse_field<'a>(line: &'a str) -> Result<(&'a str, &'a 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.len();
-                current_section_name = line[1..len - 1].trim();
+                let len = line.bytes().count();
+                current_section_name = &line[1..len - 1].trim();
             }
             (Some('['), v) => {
                 return Err(format!(

src/widgets/backlight.rs

@@ -1,6 +1,6 @@
 use std::{
     fs::{self, OpenOptions},
-    io::{Error, Write},
+    io::{Error, ErrorKind, 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::other("unable to parse value"))
+        .map_err(|_e| Error::new(ErrorKind::Other, "unable to parse value"))
 }
 
 fn write_file_as_u64(path: &Path, value: u64) -> Result<(), Error> {
@@ -32,35 +32,23 @@ pub struct Backlight {
     dirty: bool,
 }
 
-/// First device under /sys/class/backlight, if any. `min_depth(1)` skips the
-/// class directory itself, which otherwise got picked up as a "device".
-fn find_device() -> Option<PathBuf> {
-    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;
-        }
+        self.cur = read_file_as_u64(self.device_path.join("brightness").as_path()).unwrap();
+        self.max = read_file_as_u64(self.device_path.join("max_brightness").as_path()).unwrap();
     }
 
-    // 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 device_path = match path {
-            Some(path) => Some(Path::new("/sys/class/backlight").join(path)),
-            None => find_device(),
-        };
+        let mut device_path = None;
+        if let Some(path) = path {
+            device_path = Some(Path::new("/sys/class/backlight").to_path_buf().join(path));
+        } 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,
@@ -73,15 +61,18 @@ impl Backlight {
     }
 
     pub fn detect() -> bool {
-        find_device().is_some()
+        for entry in WalkDir::new("/sys/class/backlight") {
+            if entry.is_ok() {
+                return true;
+            }
+        }
+        return false;
     }
 
     pub fn set(&mut self, brightness: f32) {
-        let val = (self.max as f32 * brightness.clamp(0.0, 1.0)) as u64;
+        let val = (self.max as f32 * brightness) as u64;
         let _ = write_file_as_u64(self.device_path.join("brightness").as_path(), val);
-        if let Ok(cur) = read_file_as_u64(self.device_path.join("brightness").as_path()) {
-            self.cur = cur;
-        }
+        self.cur = read_file_as_u64(self.device_path.join("brightness").as_path()).unwrap();
     }
 }
 
@@ -93,7 +84,7 @@ impl BarWidgetImpl for Backlight {
         self.dirty
     }
     fn value(&mut self) -> f32 {
-        if self.max == 0 || self.cur > self.max {
+        if self.cur > self.max {
             // what.
             return 1.0;
         }
@@ -106,8 +97,9 @@ impl BarWidgetImpl for Backlight {
     }
     fn click(&mut self, pos: f32, btn: PointerButton) {
         self.dirty = true;
-        if let PointerButton::Left = btn {
-            self.set(pos)
+        match btn {
+            PointerButton::Left => self.set(pos),
+            _ => (),
         };
     }
 }

src/widgets/bar_widget.rs

@@ -62,13 +62,21 @@ impl Widget for BarWidget {
         let val = self.inner_widget.value();
 
         let c = self.inner_widget.color();
-        let bar_width = self.geometry.width.saturating_sub(bar_offset);
-        if bar_width < 2 {
-            return self.geometry;
-        }
-        draw_bar(&mut view.offset((bar_offset, 0)), c, bar_width, size, val).unwrap();
+        draw_bar(
+            &mut view.offset((bar_offset, 0)),
+            c,
+            self.geometry.width - bar_offset,
+            size,
+            val,
+        )
+        .unwrap();
 
-        draw_box(&mut view.offset((bar_offset, 0)), c, (bar_width, size)).unwrap();
+        draw_box(
+            &mut view.offset((bar_offset, 0)),
+            c,
+            (self.geometry.width - bar_offset, size),
+        )
+        .unwrap();
         self.geometry
     }
 
@@ -79,7 +87,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,
@@ -97,12 +105,15 @@ impl Widget for BarWidget {
     }
 
     fn event(&mut self, event: &Event) {
-        if let Event::PointerEvent(ev) = event {
-            let offset = 4 * self.size.ceil() as u32;
-            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);
+        match event {
+            Event::PointerEvent(ev) => {
+                let offset = 4 * self.size.ceil() as u32;
+                if ev.pos.0 >= offset {
+                    let val = (ev.pos.0 - offset) as f32 / (self.geometry.width - offset) as f32;
+                    self.inner_widget.click(val, ev.button);
+                }
             }
+            _ => (),
         }
     }
 }

src/widgets/battery.rs

@@ -6,8 +6,8 @@ use std::{
 };
 
 use dbus::blocking::{
-    LocalConnection,
     stdintf::org_freedesktop_dbus::{Properties, PropertiesPropertiesChanged},
+    LocalConnection,
 };
 
 use crate::{
@@ -47,87 +47,77 @@ struct InnerBattery {
     dirty: bool,
 }
 
-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>> {
+fn get_battery_state() -> Result<UpowerBatteryState, 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 present: bool = proxy.get(DEVICE_IFACE, "IsPresent")?;
-    Ok(present)
-}
-
-fn monitor(
-    inner: Arc<Mutex<InnerBattery>>,
-    events: Arc<Mutex<Events>>,
-) -> Result<(), Box<dyn Error>> {
-    let conn = LocalConnection::new_system()?;
-    let proxy = conn.with_proxy(
-        "org.freedesktop.UPower",
-        DEVICE_PATH,
-        Duration::from_millis(500),
-    );
-
-    let capacity: f64 = proxy.get(DEVICE_IFACE, "Percentage")?;
-    let state: u32 = proxy.get(DEVICE_IFACE, "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.match_signal(
-        move |c: PropertiesPropertiesChanged, _: &LocalConnection, _: &dbus::Message| {
-            if c.interface_name != DEVICE_IFACE {
-                return true;
-            }
-            let mut inner = inner.lock().unwrap();
-            for (key, value) in c.changed_properties {
-                match key.as_str() {
-                    "State" => {
-                        if let Some(v) = value.0.as_u64() {
-                            inner.state = UpowerBatteryState::from_dbus(v);
-                            inner.dirty = true;
-                            events.lock().unwrap().add_event(Event::PowerUpdate);
-                        }
-                    }
-                    "Percentage" => {
-                        if let Some(v) = value.0.as_f64() {
-                            inner.value = v as f32 / 100.;
-                            inner.dirty = true;
-                            events.lock().unwrap().add_event(Event::PowerUpdate);
-                        }
-                    }
-                    _ => (),
-                }
-            }
-            true
-        },
-    )?;
-
-    loop {
-        conn.process(Duration::from_millis(60000))?;
-    }
+    let state: u32 = proxy.get("org.freedesktop.UPower.Device", "State")?;
+    Ok(UpowerBatteryState::from_dbus(state as u64))
 }
 
 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);
+            let conn = LocalConnection::new_system().unwrap();
+            let device_path = "/org/freedesktop/UPower/devices/DisplayDevice";
+            let proxy = conn.with_proxy(
+                "org.freedesktop.UPower",
+                device_path,
+                Duration::from_millis(500),
+            );
+
+            let capacity: f64 = proxy
+                .get("org.freedesktop.UPower.Device", "Percentage")
+                .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);
+            }
+
+            proxy
+                .match_signal(
+                    move |c: PropertiesPropertiesChanged,
+                          _: &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 =
+                                        UpowerBatteryState::from_dbus(value.0.as_u64().unwrap());
+                                    inner.dirty = true;
+                                    let mut events = events.lock().unwrap();
+                                    events.add_event(Event::PowerUpdate);
+                                }
+                                "Percentage" => {
+                                    inner.value = value.0.as_f64().unwrap() as f32 / 100.;
+                                    inner.dirty = true;
+                                    let mut events = events.lock().unwrap();
+                                    events.add_event(Event::PowerUpdate);
+                                }
+                                _ => (),
+                            }
+                        }
+                        true
+                    },
+                )
+                .unwrap();
+
+            loop {
+                conn.process(Duration::from_millis(60000)).unwrap();
             }
         })
         .unwrap();
@@ -138,8 +128,6 @@ 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,
@@ -158,7 +146,10 @@ impl Battery {
     }
 
     pub fn detect() -> bool {
-        battery_present().unwrap_or(false)
+        match get_battery_state() {
+            Ok(_) => true,
+            Err(_) => false,
+        }
     }
 }
 

src/widgets/calendar.rs

@@ -69,7 +69,7 @@ impl Calendar {
     fn draw_month(
         &mut self,
         fonts: &mut FontMap,
-        view: &mut BufferView,
+        mut 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,7 +124,9 @@ impl Calendar {
             12 => "December",
             _ => panic!("impossible value"),
         };
-        month_font.draw_text(view, Color::WHITE, month_str).unwrap();
+        month_font
+            .draw_text(&mut view, Color::WHITE, month_str)
+            .unwrap();
 
         //
         // Draw the year
@@ -197,7 +199,7 @@ impl Calendar {
     }
 }
 
-impl Widget for Calendar {
+impl<'a> Widget for Calendar {
     fn get_dirty(&self) -> bool {
         self.dirty
     }
@@ -207,8 +209,11 @@ impl Widget for Calendar {
     }
 
     fn event(&mut self, event: &Event) {
-        if let Event::NewMinute = event {
-            self.dirty = true;
+        match event {
+            Event::NewMinute => {
+                self.dirty = true;
+            }
+            _ => (),
         }
     }
 
@@ -294,8 +299,9 @@ impl Widget for Calendar {
         self.geometry = Geometry {
             x: geometry.x,
             y: geometry.y,
-            width: cal_width * self.shown_sections_x + cal_pad * (self.shown_sections_x - 1),
-            height: cal_height * self.shown_sections_y,
+            width: cal_width * self.shown_sections_x as u32
+                + cal_pad * (self.shown_sections_x as u32 - 1),
+            height: cal_height * self.shown_sections_y as u32,
         };
         self.geometry
     }
@@ -317,7 +323,7 @@ impl Widget for Calendar {
                     y: 0,
                     width: 0,
                     height: 0,
-                };
+                }
             }
             x => x,
         };
@@ -329,7 +335,7 @@ impl Widget for Calendar {
                     y: 0,
                     width: 0,
                     height: 0,
-                };
+                }
             }
             y => y,
         };
@@ -338,8 +344,8 @@ impl Widget for Calendar {
         Geometry {
             x: 0,
             y: 0,
-            width,
-            height,
+            width: width,
+            height: height,
         }
     }
 }

src/widgets/clock.rs

@@ -19,7 +19,7 @@ pub struct Clock {
     colon_width: u32,
 }
 
-impl Clock {
+impl<'a> 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 Clock {
     }
 }
 
-impl Widget for Clock {
+impl<'a> Widget for Clock {
     fn get_dirty(&self) -> bool {
         self.dirty
     }
@@ -43,8 +43,11 @@ impl Widget for Clock {
     }
 
     fn event(&mut self, event: &Event) {
-        if let Event::NewMinute = event {
-            self.dirty = true;
+        match event {
+            Event::NewMinute => {
+                self.dirty = true;
+            }
+            _ => (),
         }
     }
 

src/widgets/date.rs

@@ -29,7 +29,7 @@ impl Date {
     }
 }
 
-impl Widget for Date {
+impl<'a> Widget for Date {
     fn get_dirty(&self) -> bool {
         self.dirty
     }
@@ -39,8 +39,11 @@ impl Widget for Date {
     }
 
     fn event(&mut self, event: &Event) {
-        if let Event::NewMinute = event {
-            self.dirty = true;
+        match event {
+            Event::NewMinute => {
+                self.dirty = true;
+            }
+            _ => (),
         }
     }
 

src/widgets/launcher.rs

@@ -1,10 +1,10 @@
 use std::{
-    cmp::{Ordering, max, min},
+    cmp::{max, min, Ordering},
     collections::HashMap,
     default::Default,
-    fs::{File, read_to_string},
+    fs::{read_to_string, File},
     io::Write,
-    process::{Command, exit},
+    process::{exit, Command},
     sync::{Arc, Mutex},
     thread,
 };
@@ -14,18 +14,18 @@ use crate::{
     color::Color,
     event::{Event, Events, PointerButton, PointerEvent},
     fonts::FontMap,
-    keyboard::{KeyEvent, keysyms},
+    keyboard::{keysyms, KeyEvent},
     utils::{
-        desktop::{Desktop, load_desktop_cache, load_desktop_files, write_desktop_cache},
+        desktop::{load_desktop_cache, load_desktop_files, write_desktop_cache, Desktop},
         xdg,
     },
     widgets::{Geometry, Widget},
 };
 
-use fuzzy_matcher::FuzzyMatcher;
 use fuzzy_matcher::skim::SkimMatcherV2;
+use fuzzy_matcher::FuzzyMatcher;
 use unicode_segmentation::UnicodeSegmentation;
-use wayland_client::{WEnum, protocol::wl_keyboard};
+use wayland_client::{protocol::wl_keyboard, WEnum};
 
 struct Matcher {
     matches: HashMap<Desktop, i64>,
@@ -96,19 +96,13 @@ 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;
-        } else if new_cursor > len {
-            self.cursor = len as usize;
+            return;
+        } else if new_cursor > self.input.len() as isize {
+            self.cursor = self.input.len()
         } else {
             self.cursor = new_cursor as usize;
         }
@@ -116,11 +110,11 @@ impl Prompt {
 
     fn set(&mut self, v: &str) {
         self.input = v.to_string();
-        self.cursor = self.len();
+        self.cursor = self.input.len();
     }
 
     fn append(&mut self, v: &str) {
-        if self.input.is_empty() {
+        if self.input.len() == 0 {
             match v {
                 "!" => {
                     self.mode = PromptMode::Shell;
@@ -134,14 +128,13 @@ impl Prompt {
             }
         }
         let indices: Vec<(usize, &str)> = self.input.grapheme_indices(true).collect();
-        if self.cursor >= indices.len() {
-            self.cursor = indices.len();
-            self.input += v;
+        if 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 += v.graphemes(true).count();
+        self.cursor += 1;
     }
 
     fn backspace(&mut self) {
@@ -175,7 +168,6 @@ 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);
@@ -187,7 +179,6 @@ 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);
@@ -202,32 +193,11 @@ impl Prompt {
     }
 
     fn end(&mut self) {
-        self.cursor = self.len();
+        self.cursor = self.input.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,
@@ -271,7 +241,7 @@ impl Launcher {
 
         Launcher {
             next_token: None,
-            options,
+            options: options,
             matches: Vec::new(),
             launch_cmd,
         }
@@ -288,26 +258,24 @@ impl Launcher {
         } else {
             cmd.arg(cmdline);
         }
-        match cmd.spawn() {
-            Ok(_) => exit(0),
-            Err(e) => {
-                eprintln!("wldash: failed to launch {:?}: {}", cmdline, e);
-                exit(1);
-            }
-        }
+        cmd.spawn().unwrap();
+        exit(0);
     }
 }
 
 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 {
-                self.exec(&strip_field_codes(exec));
+                let exec = exec
+                    .replace("\\\\", "\\")
+                    .replace("%f", "")
+                    .replace("%F", "")
+                    .replace("%u", "")
+                    .replace("%U", "");
+
+                self.exec(&exec);
             }
         }
     }
@@ -354,7 +322,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();
@@ -378,9 +346,8 @@ impl InterfaceWidget for Launcher {
                     .fuzzy_indices(&m.name.to_lowercase(), &intf.prompt.input.to_lowercase())
                     .unwrap_or((0, vec![]));
 
-                let nchars = m.name.chars().count();
-                let mut colors = Vec::with_capacity(nchars);
-                for pos in 0..nchars {
+                let mut colors = Vec::with_capacity(m.name.len());
+                for pos in 0..m.name.len() {
                     if indices.contains(&pos) {
                         colors.push(Color::LIGHTORANGE);
                     } else {
@@ -428,21 +395,12 @@ impl Shell {
         if let Some(token) = &self.next_token {
             cmd.env("XDG_ACTIVATION_TOKEN", token);
         }
-        match cmd.args(&args[1..]).spawn() {
-            Ok(_) => exit(0),
-            Err(e) => {
-                eprintln!("wldash: failed to run {:?}: {}", args, e);
-                exit(1);
-            }
-        }
+        cmd.args(&args[1..]).spawn().unwrap();
+        exit(0);
     }
 }
 
 impl InterfaceWidget for Shell {
-    fn rows(&self) -> usize {
-        1
-    }
-
     fn trigger(&mut self, intf: &mut InnerInterface) {
         let args = vec![
             "/bin/sh".to_string(),
@@ -474,7 +432,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();
@@ -531,18 +489,13 @@ impl Calc {
 
         let old = self.old.lock().unwrap();
         for (input, res) in old.iter() {
-            writeln!(f, "{}={}", input, res).unwrap();
+            write!(f, "{}={}\n", 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 {
@@ -567,7 +520,10 @@ 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 = res.ok();
+        self.result = match res {
+            Ok(v) => Some(v),
+            Err(_) => None,
+        };
     }
 
     fn draw(
@@ -590,7 +546,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();
@@ -686,10 +642,7 @@ impl Interface {
     fn pointer_input(&mut self, event: &PointerEvent) {
         if let PointerButton::Left = event.button {
             let line_height = self.inner.size.ceil() as u32;
-            if line_height == 0 {
-                return;
-            }
-            let height = self.inner.geometry.height.saturating_sub(line_height + 8);
+            let height = self.inner.geometry.height - line_height - 8;
             let lines = height / line_height;
 
             let offset = height % line_height;
@@ -698,18 +651,13 @@ impl Interface {
             } else {
                 return;
             };
-            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.selection = (lines - pos / line_height - 1) as usize;
             self.inner.dirty = true;
         }
     }
 
     fn exit(&mut self) {
-        if self.inner.prompt.input.is_empty() {
+        if self.inner.prompt.input.len() == 0 {
             std::process::exit(0);
         }
 
@@ -765,10 +713,7 @@ 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;
-                }
+                self.inner.selection += 1;
             }
             keysyms::KEY_Down => {
                 if self.inner.selection > 0 {
@@ -777,7 +722,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 {
@@ -807,7 +752,7 @@ impl Widget for Interface {
     }
 
     fn geometry_update(&mut self, _fonts: &mut FontMap, geometry: &Geometry) -> Geometry {
-        self.inner.geometry = *geometry;
+        self.inner.geometry = geometry.clone();
         self.inner.geometry
     }
 
@@ -837,56 +782,3 @@ 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");
-    }
-}

src/widgets/layout.rs

@@ -1,6 +1,3 @@
-// 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};
@@ -33,7 +30,7 @@ impl Layout for HorizontalLayout {
         geometry: &Geometry,
         state: &mut State,
     ) -> Geometry {
-        let mut geo = *geometry;
+        let mut geo = geometry.clone();
         let mut max_width = 0;
         let mut max_height = 0;
         for w in self.widgets.iter() {
@@ -82,7 +79,7 @@ impl Layout for VerticalLayout {
         geometry: &Geometry,
         state: &mut State,
     ) -> Geometry {
-        let mut geo = *geometry;
+        let mut geo = geometry.clone();
         let mut max_width = 0;
         let mut max_height = 0;
         for w in self.widgets.iter() {
@@ -116,7 +113,7 @@ impl Layout for VerticalLayout {
 
 pub trait WidgetUpdater {
     fn geometry_update(&mut self, idx: usize, fonts: &mut FontMap, geometry: &Geometry)
-    -> Geometry;
+        -> Geometry;
     fn minimum_size(&mut self, idx: usize, fonts: &mut FontMap) -> Geometry;
 }
 
@@ -162,10 +159,10 @@ impl Layout for InvertedHorizontalLayout {
         geometry: &Geometry,
         state: &mut State,
     ) -> Geometry {
-        let mut geo = *geometry;
+        let mut geo = geometry.clone();
         let mut max_height = 0;
         for w in self.widgets.iter() {
-            let mut temp_geo = geo;
+            let mut temp_geo = geo.clone();
             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);
@@ -210,10 +207,10 @@ impl Layout for InvertedVerticalLayout {
         geometry: &Geometry,
         state: &mut State,
     ) -> Geometry {
-        let mut geo = *geometry;
+        let mut geo = geometry.clone();
         let mut max_width = 0;
         for w in self.widgets.iter() {
-            let mut temp_geo = geo;
+            let mut temp_geo = geo.clone();
             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);

src/widgets/pulseaudio.rs

@@ -26,13 +26,13 @@ fn monitor(
     use libpulse_binding::{
         callbacks::ListResult,
         context::{
-            Context, FlagSet, State,
             subscribe::{Facility, InterestMaskSet},
+            Context, FlagSet, State,
         },
         mainloop::{
             self, api::Mainloop, events::io::FlagSet as IoFlagSet, standard::IterateResult,
         },
-        proplist::{Proplist, properties},
+        proplist::{properties, Proplist},
         volume::Volume,
     };
 
@@ -48,17 +48,10 @@ fn monitor(
     context.borrow_mut().connect(None, FlagSet::NOFLAGS, None)?;
 
     loop {
-        match mainloop.iterate(true) {
-            IterateResult::Quit(_) | IterateResult::Err(_) => {
-                return Err("pulseaudio mainloop quit while connecting".into());
-            }
-            _ => (),
-        }
+        mainloop.iterate(false);
         match context.borrow().get_state() {
             State::Ready => break,
-            State::Failed | State::Terminated => {
-                return Err("could not connect to pulseaudio".into());
-            }
+            State::Failed | State::Terminated => panic!("damn"),
             _ => (),
         }
     }
@@ -67,15 +60,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| {
-            if let Some(Facility::Sink) = facility {
+        move |facility, _operation, index| match facility {
+            Some(Facility::Sink) => {
                 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 sink_info.name.is_some() {
+                        if let Some(_) = &sink_info.name {
                             let avg = sink_info.volume.avg().0 as f32 / Volume::NORMAL.0 as f32;
                             let mut inner = inner.lock().unwrap();
                             inner.volume = avg;
@@ -88,6 +81,7 @@ fn monitor(
                     }
                 });
             }
+            _ => (),
         },
     )));
 
@@ -100,7 +94,7 @@ fn monitor(
     introspector.get_sink_info_by_name("@DEFAULT_SINK@", move |res| match res {
         ListResult::End | ListResult::Error => (),
         ListResult::Item(sink_info) => {
-            if sink_info.name.is_some() {
+            if let Some(_) = &sink_info.name {
                 let avg = sink_info.volume.avg().0 as f32 / Volume::NORMAL.0 as f32;
                 let mut inner = local_inner.lock().unwrap();
                 inner.volume = avg;
@@ -118,7 +112,7 @@ fn monitor(
     let local_context = context.clone();
     let local_inner = inner.clone();
     let event_source = mainloop.new_io_event(
-        pipe,
+        pipe as i32,
         IoFlagSet::INPUT,
         Box::new(move |_, _, _| {
             let mut buf = [0; 8];
@@ -126,14 +120,15 @@ fn monitor(
 
             let mut inner = local_inner.lock().unwrap();
             let mut introspector = local_context.borrow_mut().introspect();
-            // Clicks arriving before the first sink query finished have no
-            // channel map to work with; drop them instead of panicking.
-            match (inner.last_click.take(), inner.channel_volume) {
-                (Some(Change::Volume(volume)), Some(mut vol)) => {
+            match inner.last_click.take() {
+                Some(Change::Volume(volume)) => {
+                    // do something
+                    let mut vol = inner.channel_volume.unwrap();
                     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(mut vol)) => {
+                Some(Change::VolumeInc(value)) => {
+                    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 {
@@ -146,10 +141,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 => (),
             }
         }),
     );
@@ -170,13 +165,7 @@ fn monitor(
 fn start_monitor(events: Arc<Mutex<Events>>, inner: Arc<Mutex<InnerAudio>>, pipe: RawFd) {
     thread::Builder::new()
         .name("audiomon".to_string())
-        .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);
-            }
-        })
+        .spawn(move || monitor(events, inner, pipe).unwrap())
         .unwrap();
 }
 
@@ -200,8 +189,6 @@ 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,

src/widgets/widget.rs

@@ -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.y) - y,
+            height: max(self.height + self.y, other.height + other.height) - y,
         }
     }
 
@@ -64,33 +64,3 @@ 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)
-        );
-    }
-}