Commit 92928dd

remage92928dd

Add input and config: action grammar, keymap, live TOML config

Implement M2: one action grammar (parse and Display round-trip) shared by
keys, palette, IPC and command output; vim key notation and a per-mode
keymap trie with sequences, counts, ambiguity timeout and mouse/wheel
bindings; a TOML config whose compiled-in default is default.toml, with
includes, file:line:col errors with suggestions, --dump-config and
--check-config; live reload on file change, SIGUSR1 and reload-config;
theme presets, token derivation, pywal import and a 250 ms theme
crossfade, plus matugen and pywal templates.

Author: krolyxon
Date: 2026-11-04 20:32 +0530
Parent: f2bd31a
Commit: 92928ddec989b376ad2471df4e65afeeec05e3bd

+4268 −289

22 files changed

Browse files Patch

−Context 3+

M CLAUDE.md +1 −1
A contrib/matugen/remage.toml +16 −0
A contrib/pywal/remage.toml +15 −0
M src/action.rs +827 −8
M src/app.rs +391 −55
M src/cache.rs +5 −0
M src/cli.rs +18 −6
A src/config/default.toml +175 −0
M src/config/mod.rs +1046 −1
M src/config/theme.rs +237 −22
A src/config/watch.rs +143 −0
M src/input/keymap.rs +435 −0
M src/input/keys.rs +437 −1
M src/input/mod.rs +95 −148
M src/main.rs +72 −13
M src/render/mod.rs +4 −0
M src/render/text.rs +19 −5
M src/scan.rs +6 −1
M src/state/mod.rs +244 −19
M src/state/queue.rs +64 −1
M src/state/view.rs +13 −1
M src/ui/mod.rs +5 −7

M CLAUDE.md View

A contrib/matugen/remage.toml View

A contrib/pywal/remage.toml View

M src/action.rs View

M src/app.rs View

M src/cache.rs View

M src/cli.rs View

A src/config/default.toml View

M src/config/mod.rs View

M src/config/theme.rs View

A src/config/watch.rs View

M src/input/keymap.rs View

M src/input/keys.rs View

M src/input/mod.rs View

M src/main.rs View

M src/render/mod.rs View

M src/render/text.rs View

M src/scan.rs View

M src/state/mod.rs View

M src/state/queue.rs View

M src/state/view.rs View

M src/ui/mod.rs View

		@@ -430,7 +430,7 @@ Each milestone should end with a usable binary.
430	430		- winit + wgpu window, decoding through the `image` crate.
431	431		- Fit/zoom/pan/rotate/flip with animation, and `n`/`p`.
432	432		- Preload + cache, a status bar with text, and the `nothing-dark` theme with hard-coded keys.
433		−	- M2 Input + config
	433	+	- M2 Input + config ✓ (2026-11-04). Unbuilt actions parse and bind, then say "not available yet".
434	434		- Action grammar, and a keymap trie with sequences, counts and mouse bindings.
435	435		- TOML defaults, include and live reload, plus `--dump-config` and `--check-config`.
436	436		- Theme tokens, presets and derivation; matugen + pywal support.

	@@ -0,0 +1,16 @@
1	+	# matugen template for remage.
2	+	#
3	+	# 1. Copy to ~/.config/matugen/templates/remage.toml
4	+	# 2. In ~/.config/matugen/config.toml:
5	+	# [templates.remage]
6	+	# input_path = '~/.config/matugen/templates/remage.toml'
7	+	# output_path = '~/.cache/matugen/remage.toml'
8	+	# 3. In ~/.config/remage/config.toml:
9	+	# include = ["~/.cache/matugen/remage.toml"]
10	+	#
11	+	# remage watches the include, so every wallpaper change recolours open windows; no post_hook.
12	+	# Only three colours are needed: every other token is derived from them.
13	+	[theme]
14	+	background = "{{colors.surface_container_lowest.default.hex}}"
15	+	foreground = "{{colors.on_surface.default.hex}}"
16	+	accent = "{{colors.primary.default.hex}}"

	@@ -0,0 +1,15 @@
1	+	# pywal template for remage.
2	+	#
3	+	# remage can read pywal's colors.json directly, which needs no template:
4	+	# [theme]
5	+	# pywal = "~/.cache/wal/colors.json"
6	+	#
7	+	# To go through a template instead (to pick other colours), copy this file to
8	+	# ~/.config/wal/templates/remage.toml and add to ~/.config/remage/config.toml:
9	+	# include = ["~/.cache/wal/remage.toml"]
10	+	#
11	+	# remage watches the include, so `wal -i <image>` recolours open windows.
12	+	[theme]
13	+	background = "{background}"
14	+	foreground = "{foreground}"
15	+	accent = "{color1}"

		@@ -41,13 +41,13 @@ pub struct Cli {
41	41		#[arg(short = 'g', long, value_name = "WxH", value_parser = parse_geometry)]
42	42		pub geometry: Option<(u32, u32)>,
43	43
44		−	/// Wayland app_id / X11 class
45		−	#[arg(long, value_name = "NAME", default_value = "remage")]
46		−	pub class: String,
	44	+	/// Wayland app_id / X11 class [default: remage]
	45	+	#[arg(long, value_name = "NAME")]
	46	+	pub class: Option<String>,
47	47
48		−	/// Sort order for directory contents
49		−	#[arg(long, value_enum, value_name = "KEY", default_value = "natural")]
50		−	pub sort: SortKey,
	48	+	/// Sort order for directory contents [default: natural]
	49	+	#[arg(long, value_enum, value_name = "KEY")]
	50	+	pub sort: Option<SortKey>,
51	51
52	52		/// Reverse the sort order
53	53		#[arg(long)]
		@@ -56,6 +56,18 @@ pub struct Cli {
56	56		/// Open only the named file, not the rest of its directory
57	57		#[arg(long)]
58	58		pub no_siblings: bool,
	59	+
	60	+	/// Config file [default: $XDG_CONFIG_HOME/remage/config.toml]
	61	+	#[arg(short = 'c', long, value_name = "PATH")]
	62	+	pub config: Option<PathBuf>,
	63	+
	64	+	/// Print the full commented default config and exit
	65	+	#[arg(long)]
	66	+	pub dump_config: bool,
	67	+
	68	+	/// Validate the config and exit non-zero on errors
	69	+	#[arg(long)]
	70	+	pub check_config: bool,
59	71		}
60	72
61	73		fn parse_geometry(s: &str) -> Result<(u32, u32), String> {

	@@ -0,0 +1,175 @@
1	+	# remage configuration — the complete default.
2	+	#
3	+	# Copy only what you want to change into ~/.config/remage/config.toml: your file is merged
4	+	# over these defaults, so a partial file is fine. `remage --check-config` validates it.
5	+	# Changes apply live, and SIGUSR1 or the `reload-config` action reload by hand.
6	+
7	+	# Files merged before this one, in order; this file wins. `~` and `$VAR` expand, relative
8	+	# paths resolve against this file's directory, and a missing include is only a warning.
9	+	# include = ["~/.cache/matugen/remage.toml"]
10	+	include = []
11	+
12	+	[general]
13	+	open_siblings = true # a single file argument opens its whole directory
14	+	recursive = false # descend into directory arguments
15	+	sort = "natural" # natural \| name \| mtime \| size \| random
16	+	reverse = false
17	+	start_mode = "image" # image \| grid
18	+	wrap = true # next on the last image goes to the first
19	+	watch_dir = true # add and drop files that appear or vanish on disk
20	+
21	+	[window]
22	+	decorations = false
23	+	title = "{name} — remage" # {name} {index} {count}
24	+	class = "remage" # Wayland app_id / X11 class
25	+	fullscreen = false
26	+
27	+	[image]
28	+	fit = "down" # down (fit, never enlarge) \| fit \| fill \| width \| height \| original
29	+	zoom_step = 1.25
30	+	filter = "auto" # auto (nearest above 300%) \| linear \| nearest
31	+	alpha_background = "dots" # dots \| checker \| solid
32	+	auto_orient = true # apply EXIF orientation
33	+	color_management = true # convert ICC / CICP colour to sRGB
34	+	preload = 2 # images decoded and uploaded on each side
35	+	cache_mb = 512 # decoded-image cache budget
36	+	slideshow_delay = 5.0 # seconds
37	+
38	+	[grid]
39	+	sizes = [96, 128, 160, 224, 320]
40	+	size = 160
41	+	gap = 16
42	+	thumbnail_cache = true # read and write the shared freedesktop thumbnail cache
43	+	names = false # filenames under thumbnails
44	+
45	+	[ui]
46	+	statusbar = true
47	+	which_key_delay_ms = 300
48	+	scale = 1.0 # UI size multiplier on top of the display scale
49	+	statusbar_left = "{name}"
50	+	statusbar_right = "{format} {width}×{height} {zoom}% {index}/{count}"
51	+	info_command = "" # script whose output fills a status segment
52	+	font_ui = "Space Grotesk"
53	+	font_mono = "Space Mono"
54	+	font_display = "Doto"
55	+
56	+	[animation]
57	+	enabled = true
58	+	duration_ms = 180
59	+	transition = "fade" # fade \| none
60	+
61	+	[theme]
62	+	preset = "nothing-dark" # nothing-dark \| nothing-light
63	+	# Read colours from pywal: special.background / special.foreground / colors.color1.
64	+	# pywal = "~/.cache/wal/colors.json"
65	+	#
66	+	# background, foreground and accent are enough; every other token is derived from them.
67	+	# Any token can be set explicitly as "#RRGGBB" or "#RRGGBBAA":
68	+	# background = "#000000"
69	+	# foreground = "#FFFFFF"
70	+	# accent = "#D71921"
71	+	# surface surface_raised border border_visible text_disabled text_secondary
72	+	# text_primary text_display success warning image_background
73	+
74	+	# Key bindings. Values are an action, an array of actions run in order, or "none" to remove
75	+	# a default. Mode tables override [keys.global]; visual mode also inherits [keys.grid].
76	+	# Notation is vim's: n G <C-x> <S-Tab> <Space>w <CR> <BS> <Esc> <F5> <lt> <Bar>, plus
77	+	# <LeftMouse> <RightMouse> <MiddleMouse> <ScrollUp> <ScrollDown> with modifiers (<C-ScrollUp>).
78	+	# A count typed first applies to the action: 5n, 12G, 3+.
79	+
80	+	[keys.global]
81	+	"q" = "quit"
82	+	"<CR>" = "mode toggle"
83	+	"n" = "next"
84	+	"p" = "prev"
85	+	"<BS>" = "prev"
86	+	"]" = "next 10"
87	+	"[" = "prev 10"
88	+	"gg" = "first"
89	+	"G" = "last"
90	+	"<Home>" = "first"
91	+	"<End>" = "last"
92	+	"m" = "mark"
93	+	"M" = "invert-marks"
94	+	"u" = "unmark-all"
95	+	"N" = "next-mark"
96	+	"P" = "prev-mark"
97	+	"f" = "fullscreen"
98	+	"b" = "bar"
99	+	"i" = "info"
100	+	"r" = "reload"
101	+	"D" = "remove"
102	+	"s" = "slideshow"
103	+	":" = "palette"
104	+	"/" = "search"
105	+	"?" = "help"
106	+	"<Esc>" = "cancel"
107	+
108	+	[keys.image]
109	+	"h" = "pan left"
110	+	"j" = "pan down"
111	+	"k" = "pan up"
112	+	"l" = "pan right"
113	+	"<Left>" = "pan left"
114	+	"<Down>" = "pan down"
115	+	"<Up>" = "pan up"
116	+	"<Right>" = "pan right"
117	+	"H" = "pan-edge left"
118	+	"J" = "pan-edge down"
119	+	"K" = "pan-edge up"
120	+	"L" = "pan-edge right"
121	+	"z" = "center"
122	+	"+" = "zoom in"
123	+	"-" = "zoom out"
124	+	"=" = "zoom 100%"
125	+	"w" = "fit fit"
126	+	"W" = "fit fill"
127	+	"e" = "fit width"
128	+	"E" = "fit height"
129	+	"<lt>" = "rotate ccw"
130	+	">" = "rotate cw"
131	+	"\|" = "flip h"
132	+	"_" = "flip v"
133	+	"a" = "filter toggle"
134	+	"A" = "alpha-bg cycle"
135	+	"{" = "gamma -"
136	+	"}" = "gamma +"
137	+	"<C-Space>" = "play"
138	+	"<C-n>" = "next-frame"
139	+	"<C-p>" = "prev-frame"
140	+	"<ScrollUp>" = "zoom in"
141	+	"<ScrollDown>" = "zoom out"
142	+
143	+	[keys.grid]
144	+	"+" = "grid-size +"
145	+	"-" = "grid-size -"
146	+	"v" = "visual"
147	+
148	+	[keys.visual]
149	+	"m" = "mark on"
150	+	"<Esc>" = "mode grid"
151	+
152	+	# User commands: bind them as "run <name>"; unbound ones still show in the : palette.
153	+	#
154	+	# [commands.wallpaper]
155	+	# desc = "Set as wallpaper"
156	+	# run = ["setwall", "-p", "{file}"] # array: exec directly, {files} expands to N args
157	+	#
158	+	# [commands.copy]
159	+	# desc = "Copy image"
160	+	# run = "wl-copy --type image/png < {file}" # string: sh -c, placeholders shell-quoted
161	+	#
162	+	# [commands.delete]
163	+	# desc = "Delete files"
164	+	# run = ["rm", "--", "{files}"]
165	+	# confirm = "Delete {count} file(s)?"
166	+	#
167	+	# Fields: targets = auto \| current \| marked \| all, stdin = none \| files \| files0,
168	+	# output = status \| actions \| ignore, after = actions run on success (default "refresh").
169	+	# Placeholders: {file} {files} {dir} {name} {stem} {ext} {index} {count} {width} {height}.
170	+	[commands]
171	+
172	+	# External decoders for anything else; they write PNG, PPM or TIFF to stdout.
173	+	# [[decoders]]
174	+	# match = ["*.psd"]
175	+	# run = ["magick", "{file}[0]", "png:-"]

		@@ -13,14 +13,18 @@ use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoopProxy};
13	13		use winit::keyboard::{ModifiersState, PhysicalKey};
14	14		use winit::window::{Fullscreen, Window, WindowId};
15	15
16		−	use crate::action::Action;
	16	+	use crate::action::{Action, Switch, Zoom};
17	17		use crate::cache::ImageCache;
18		−	use crate::config::theme::Theme;
	18	+	use crate::config::watch::ConfigWatch;
	19	+	use crate::config::{Config, LoadError, Loaded};
19	20		use crate::decode::{self, DecodedImage};
20		−	use crate::input::{self, Input};
	21	+	use crate::input::keymap::{KeyTables, Keymap};
	22	+	use crate::input::keys::{Key, Scroll};
	23	+	use crate::input::{self};
21	24		use crate::render::{Renderer, text};
22		−	use crate::state::view::Dir;
23		−	use crate::state::{AppState, Effects, MsgKind};
	25	+	use crate::scan;
	26	+	use crate::state::view::{Dir, FitMode};
	27	+	use crate::state::{AppState, Effects, MsgKind, Settings};
24	28		use crate::ui;
25	29		use crate::worker::{JobKey, Pool, Priority};
26	30
		@@ -30,6 +34,13 @@ const UPLOAD_BUDGET: usize = 32 << 20;
30	34		const SHOW_TIMEOUT: Duration = Duration::from_millis(300);
31	35		/// Wheel pixels per zoom step for touchpads.
32	36		const PIXELS_PER_STEP: f32 = 60.0;
	37	+	/// An ambiguous key sequence (`g` bound, and `gg` too) resolves after this long, like vim's
	38	+	/// `timeoutlen`.
	39	+	const SEQUENCE_TIMEOUT: Duration = Duration::from_millis(1000);
	40	+	/// A press and release closer than this is a click, not a drag.
	41	+	const CLICK_SLOP: f32 = 4.0;
	42	+	/// Config errors stay on screen until fixed (or dismissed with `<Esc>`).
	43	+	const CONFIG_ERROR_TIME: Duration = Duration::from_secs(3600);
33	44
34	45		pub enum UserEvent {
35	46		Decoded {
		@@ -40,13 +51,36 @@ pub enum UserEvent {
40	51		Found(Vec<PathBuf>),
41	52		/// Embedded plus system fonts, loaded off-thread after the first frame.
42	53		Fonts(glyphon::fontdb::Database),
	54	+	/// The config was reloaded (file change, SIGUSR1 or `reload-config`).
	55	+	Config(Box<Result<Loaded, LoadError>>),
	56	+	/// A re-sort finished: the queue in its new order.
	57	+	Sorted(Vec<PathBuf>),
	58	+	}
	59	+
	60	+	/// Command-line settings that beat the config, across reloads too.
	61	+	#[derive(Clone, Debug, Default)]
	62	+	pub struct Overrides {
	63	+	pub fit: Option<FitMode>,
	64	+	pub zoom: Option<f32>,
	65	+	pub bar: Option<bool>,
	66	+	}
	67	+
	68	+	impl Overrides {
	69	+	pub fn apply(&self, s: &mut Settings) {
	70	+	if let Some(fit) = self.fit {
	71	+	s.fit = fit;
	72	+	}
	73	+	if self.zoom.is_some() {
	74	+	s.zoom = self.zoom;
	75	+	}
	76	+	}
43	77		}
44	78
45	79		pub struct Options {
46	80		pub fullscreen: bool,
47	81		pub geometry: Option<(u32, u32)>,
48	82		pub class: String,
49		−	pub cache_mb: usize,
	83	+	pub overrides: Overrides,
50	84		}
51	85
52	86		struct Gfx {
		@@ -58,8 +92,17 @@ struct Gfx {
58	92		pub struct App {
59	93		opts: Options,
60	94		state: AppState,
61		−	theme: Theme,
62		−	input: Input,
	95	+	config: Config,
	96	+	keymap: Keymap,
	97	+	watch: ConfigWatch,
	98	+	/// A config error is on the status line.
	99	+	config_error: bool,
	100	+	/// `reload-config` ran, so the next reload is confirmed on screen.
	101	+	reload_requested: bool,
	102	+	/// When the pending key sequence became ambiguous.
	103	+	ambiguous_since: Option<Instant>,
	104	+	/// Actions a held key repeats.
	105	+	repeat: Option<(PhysicalKey, Vec<Action>)>,
63	106		pool: Pool,
64	107		proxy: EventLoopProxy<UserEvent>,
65	108		cache: ImageCache,
		@@ -71,6 +114,10 @@ pub struct App {
71	114		modifiers: ModifiersState,
72	115		cursor: [f32; 2],
73	116		dragging: bool,
	117	+	/// Where the left button went down, while it is a click candidate.
	118	+	press: Option<[f32; 2]>,
	119	+	/// Wheel motion not yet turned into whole `<ScrollUp>`/`<ScrollDown>` presses.
	120	+	scroll: [f32; 2],
74	121		held: HashMap<PhysicalKey, Dir>,
75	122		started: Instant,
76	123		shown_window: bool,
		@@ -78,13 +125,24 @@ pub struct App {
78	125		}
79	126
80	127		impl App {
81		−	pub fn new(opts: Options, state: AppState, proxy: EventLoopProxy<UserEvent>) -> Self {
82		−	let cache = ImageCache::new(opts.cache_mb << 20);
	128	+	pub fn new(
	129	+	opts: Options,
	130	+	state: AppState,
	131	+	proxy: EventLoopProxy<UserEvent>,
	132	+	loaded: Loaded,
	133	+	watch: ConfigWatch,
	134	+	) -> Self {
	135	+	let cache = ImageCache::new(loaded.config.image.cache_mb << 20);
83	136		let mut app = Self {
84	137		opts,
85	138		state,
86		−	theme: Theme::nothing_dark(),
87		−	input: Input::default(),
	139	+	keymap: keymap(&loaded.keys),
	140	+	config: loaded.config,
	141	+	watch,
	142	+	config_error: false,
	143	+	reload_requested: false,
	144	+	ambiguous_since: None,
	145	+	repeat: None,
88	146		pool: Pool::new(),
89	147		proxy,
90	148		cache,
		@@ -96,6 +154,8 @@ impl App {
96	154		modifiers: ModifiersState::empty(),
97	155		cursor: [0.0, 0.0],
98	156		dragging: false,
	157	+	press: None,
	158	+	scroll: [0.0, 0.0],
99	159		held: HashMap::new(),
100	160		started: Instant::now(),
101	161		shown_window: false,
		@@ -152,8 +212,6 @@ impl App {
152	212		let now = Instant::now();
153	213		if navigated {
154	214		self.pool.bump_epoch();
155		−	self.input.cancel();
156		−	self.state.pending.clear();
157	215		}
158	216		let wanted = self.window_paths();
159	217		self.update_title();
		@@ -217,14 +275,82 @@ impl App {
217	275
218	276		fn update_title(&self) {
219	277		if let Some(g) = &self.gfx {
220		−	let title = match self.state.queue.current() {
221		−	Some(p) => format!("{} — remage", ui::file_name(p)),
	278	+	let q = &self.state.queue;
	279	+	let title = match q.current() {
	280	+	Some(p) => self
	281	+	.config
	282	+	.window
	283	+	.title
	284	+	.replace("{name}", &ui::file_name(p))
	285	+	.replace("{index}", &(q.index() + 1).to_string())
	286	+	.replace("{count}", &q.len().to_string()),
222	287		None => "remage".into(),
223	288		};
224	289		g.window.set_title(&title);
225	290		}
226	291		}
227	292
	293	+	/// Show a config error until the config is fixed.
	294	+	pub fn config_failed(&mut self, message: &str) {
	295	+	self.state.notify_for(
	296	+	format!("config error: {}", short_error(message)),
	297	+	MsgKind::Error,
	298	+	Instant::now(),
	299	+	CONFIG_ERROR_TIME,
	300	+	);
	301	+	self.config_error = true;
	302	+	self.request_redraw();
	303	+	}
	304	+
	305	+	/// Adopt a reloaded config. Runtime toggles (bar, filter, alpha background) only change
	306	+	/// when their config value did, so a reload doesn't undo what the user just toggled.
	307	+	fn apply_config(&mut self, loaded: Loaded) {
	308	+	let now = Instant::now();
	309	+	for w in &loaded.warnings {
	310	+	log::warn!("{w}");
	311	+	}
	312	+	let old = std::mem::replace(&mut self.config, loaded.config);
	313	+	let new = &self.config;
	314	+	let mut settings = Settings::from_config(new);
	315	+	self.opts.overrides.apply(&mut settings);
	316	+	let preload_changed = settings.preload != self.state.settings.preload;
	317	+	self.state.set_settings(settings);
	318	+	self.state.set_theme(loaded.theme, now);
	319	+	self.keymap = keymap(&loaded.keys);
	320	+	self.ambiguous_since = None;
	321	+	self.state.pending.clear();
	322	+	self.cache.set_budget(new.image.cache_mb << 20);
	323	+	if old.image.filter != new.image.filter {
	324	+	self.state.nearest = new.image.filter.nearest();
	325	+	}
	326	+	if old.image.alpha_background != new.image.alpha_background {
	327	+	self.state.alpha_bg = new.image.alpha_background;
	328	+	}
	329	+	if old.ui.statusbar != new.ui.statusbar && self.opts.overrides.bar.is_none() {
	330	+	let s = if new.ui.statusbar {
	331	+	Switch::On
	332	+	} else {
	333	+	Switch::Off
	334	+	};
	335	+	self.state.apply(Action::Bar(s), now);
	336	+	}
	337	+	if let Some(g) = &mut self.gfx {
	338	+	if old.window.decorations != new.window.decorations {
	339	+	g.window.set_decorations(new.window.decorations);
	340	+	}
	341	+	g.renderer.set_font_families(font_families(new));
	342	+	}
	343	+	self.update_title();
	344	+	// Silent on routine changes (a new wallpaper palette); confirm fixes and manual reloads.
	345	+	if std::mem::take(&mut self.config_error) \|\| std::mem::take(&mut self.reload_requested) {
	346	+	self.state.notify("config reloaded", MsgKind::Info, now);
	347	+	}
	348	+	if preload_changed {
	349	+	self.sync(false);
	350	+	}
	351	+	self.request_redraw();
	352	+	}
	353	+
228	354		fn on_decoded(&mut self, path: PathBuf, result: Result<Arc<DecodedImage>, String>) {
229	355		lock(&self.arriving).remove(&path);
230	356		let now = Instant::now();
		@@ -267,9 +393,20 @@ impl App {
267	393		}
268	394		}
269	395
270		−	fn apply(&mut self, action: Action, event_loop: &ActiveEventLoop) {
271		−	let fx = self.state.apply(action, Instant::now());
272		−	self.effects(fx, event_loop);
	396	+	/// Run actions in order; `anchor` is the cursor for mouse-triggered ones.
	397	+	fn run(&mut self, actions: Vec<Action>, anchor: Option<[f32; 2]>, el: &ActiveEventLoop) {
	398	+	for action in actions {
	399	+	if action == Action::Cancel {
	400	+	self.keymap.cancel();
	401	+	self.state.pending.clear();
	402	+	self.config_error = false;
	403	+	}
	404	+	let fx = self.state.apply_at(action, anchor, Instant::now());
	405	+	self.effects(fx, el);
	406	+	if fx.quit {
	407	+	return;
	408	+	}
	409	+	}
273	410		}
274	411
275	412		fn effects(&mut self, fx: Effects, event_loop: &ActiveEventLoop) {
		@@ -277,24 +414,58 @@ impl App {
277	414		event_loop.exit();
278	415		return;
279	416		}
280		−	if fx.fullscreen
	417	+	if let Some(s) = fx.fullscreen
281	418		&& let Some(g) = &self.gfx
282	419		{
283	420		let on = g.window.fullscreen().is_some();
284		−	g.window
285		−	.set_fullscreen((!on).then_some(Fullscreen::Borderless(None)));
	421	+	let want = match s {
	422	+	Switch::Toggle => !on,
	423	+	Switch::On => true,
	424	+	Switch::Off => false,
	425	+	};
	426	+	if want != on {
	427	+	g.window
	428	+	.set_fullscreen(want.then_some(Fullscreen::Borderless(None)));
	429	+	}
286	430		}
287	431		if fx.reload {
288	432		self.reload();
289	433		}
	434	+	if fx.reload_config {
	435	+	self.reload_requested = true;
	436	+	self.watch.reload();
	437	+	}
	438	+	if let Some(key) = fx.sort {
	439	+	let mut files = self.state.queue.files().to_vec();
	440	+	let proxy = self.proxy.clone();
	441	+	std::thread::spawn(move \|\| {
	442	+	scan::sort_paths(&mut files, key, false);
	443	+	let _ = proxy.send_event(UserEvent::Sorted(files));
	444	+	});
	445	+	}
290	446		if fx.navigated {
291	447		self.sync(true);
	448	+	} else if fx.reordered {
	449	+	self.sync(false);
292	450		}
293	451		if fx.redraw \|\| fx.layout {
294	452		self.request_redraw();
295	453		}
296	454		}
297	455
	456	+	/// Mirror the keymap's pending keys on the status line and arm the ambiguity timeout.
	457	+	fn update_pending(&mut self, now: Instant) {
	458	+	let pending = self.keymap.pending_display();
	459	+	if pending != self.state.pending {
	460	+	self.state.pending = pending;
	461	+	self.request_redraw();
	462	+	}
	463	+	self.ambiguous_since = self
	464	+	.keymap
	465	+	.is_ambiguous(self.state.mode)
	466	+	.then(\|\| self.ambiguous_since.unwrap_or(now));
	467	+	}
	468	+
298	469		fn on_key(&mut self, event: winit::event::KeyEvent, event_loop: &ActiveEventLoop) {
299	470		let now = Instant::now();
300	471		if event.state == ElementState::Released {
		@@ -302,27 +473,100 @@ impl App {
302	473		self.state.hold_pan(dir, false, now);
303	474		self.request_redraw();
304	475		}
	476	+	if self
	477	+	.repeat
	478	+	.as_ref()
	479	+	.is_some_and(\|(k, _)\| *k == event.physical_key)
	480	+	{
	481	+	self.repeat = None;
	482	+	}
305	483		return;
306	484		}
307		−	let action = self.input.key(&event.logical_key, self.modifiers);
308		−	let pending = self.input.pending();
309		−	if pending != self.state.pending {
310		−	self.state.pending = pending;
311		−	self.request_redraw();
	485	+	if event.repeat {
	486	+	// Repeats bypass the trie: only a completed, repeatable binding repeats.
	487	+	if let Some((k, actions)) = &self.repeat
	488	+	&& *k == event.physical_key
	489	+	{
	490	+	let actions = actions.clone();
	491	+	self.run(actions, None, event_loop);
	492	+	}
	493	+	return;
312	494		}
313		−	let Some(action) = action else { return };
314		−	if event.repeat && !input::repeats(&action) {
	495	+	let Some(key) = input::key(&event.logical_key, self.modifiers) else {
315	496		return;
	497	+	};
	498	+	let runs = self.keymap.feed(self.state.mode, key);
	499	+	self.update_pending(now);
	500	+	self.repeat = None;
	501	+	for run in runs {
	502	+	let actions = run.counted();
	503	+	if let [Action::Pan(dir)] = actions[..] {
	504	+	if self.state.shown.is_some() {
	505	+	self.held.insert(event.physical_key, dir);
	506	+	self.state.hold_pan(dir, true, now);
	507	+	self.request_redraw();
	508	+	}
	509	+	continue;
	510	+	}
	511	+	if !actions.is_empty() && actions.iter().all(Action::repeats) {
	512	+	self.repeat = Some((event.physical_key, actions.clone()));
	513	+	}
	514	+	self.run(actions, None, event_loop);
316	515		}
317		−	if let Action::Pan(dir) = action {
318		−	if self.state.shown.is_some() {
319		−	self.held.insert(event.physical_key, dir);
320		−	self.state.hold_pan(dir, true, now);
321		−	self.request_redraw();
	516	+	}
	517	+
	518	+	/// A mouse button or wheel notch: bound actions run at the cursor, bypassing sequences.
	519	+	fn on_mouse_key(&mut self, key: Key, event_loop: &ActiveEventLoop) {
	520	+	self.keymap.cancel();
	521	+	self.update_pending(Instant::now());
	522	+	if let Some(actions) = self.keymap.lookup(self.state.mode, &[key]) {
	523	+	let actions = actions.to_vec();
	524	+	self.run(actions, Some(self.cursor), event_loop);
	525	+	}
	526	+	}
	527	+
	528	+	fn on_wheel(&mut self, delta: [f32; 2], event_loop: &ActiveEventLoop) {
	529	+	let now = Instant::now();
	530	+	let [dx, dy] = delta;
	531	+	if dy != 0.0 {
	532	+	let dir = if dy > 0.0 { Scroll::Up } else { Scroll::Down };
	533	+	let key = input::scroll(dir, self.modifiers);
	534	+	// Wheel zoom stays continuous for touchpads rather than stepping per notch.
	535	+	match self.keymap.lookup(self.state.mode, &[key]) {
	536	+	Some([Action::Zoom(Zoom::In(n))]) => {
	537	+	let steps = dy.abs() * *n as f32;
	538	+	self.state.zoom_at(steps, self.cursor, now);
	539	+	self.request_redraw();
	540	+	return;
	541	+	}
	542	+	Some([Action::Zoom(Zoom::Out(n))]) => {
	543	+	let steps = -dy.abs() * *n as f32;
	544	+	self.state.zoom_at(steps, self.cursor, now);
	545	+	self.request_redraw();
	546	+	return;
	547	+	}
	548	+	_ => {}
	549	+	}
	550	+	}
	551	+	for (axis, d, pos, neg) in [
	552	+	(0, dx, Scroll::Left, Scroll::Right),
	553	+	(1, dy, Scroll::Up, Scroll::Down),
	554	+	] {
	555	+	if d == 0.0 {
	556	+	continue;
	557	+	}
	558	+	// Reversing direction drops the leftover fraction.
	559	+	if self.scroll[axis] * d < 0.0 {
	560	+	self.scroll[axis] = 0.0;
	561	+	}
	562	+	self.scroll[axis] += d;
	563	+	while self.scroll[axis].abs() >= 1.0 {
	564	+	let up = self.scroll[axis] > 0.0;
	565	+	self.scroll[axis] -= self.scroll[axis].signum();
	566	+	let key = input::scroll(if up { pos } else { neg }, self.modifiers);
	567	+	self.on_mouse_key(key, event_loop);
322	568		}
323		−	return;
324	569		}
325		−	self.apply(action, event_loop);
326	570		}
327	571
328	572		fn redraw(&mut self) {
		@@ -339,9 +583,8 @@ impl App {
339	583		if !self.shown_window {
340	584		g.window.set_visible(true);
341	585		}
342		−	let scene = ui::scene(&self.state, &self.theme, now, &mut \|t\| {
343		−	g.renderer.measure(t)
344		−	});
	586	+	let theme = self.state.theme_at(now);
	587	+	let scene = ui::scene(&self.state, &theme, now, &mut \|t\| g.renderer.measure(t));
345	588		let result = g.renderer.render(&scene);
346	589		if let Some(path) = std::env::var_os("REMAGE_SNAPSHOT")
347	590		&& !self.state.is_animating(now)
		@@ -384,6 +627,37 @@ impl App {
384	627		}
385	628		}
386	629
	630	+	/// A config error trimmed for the status line: `config.toml:2:1: unknown field `fitt`; did you
	631	+	/// mean `fit`?` without the directory or the list of every valid field.
	632	+	fn short_error(message: &str) -> String {
	633	+	let mut s = match message.split_once(": ") {
	634	+	Some((loc, rest)) if loc.contains('/') => {
	635	+	format!("{}: {rest}", loc.rsplit('/').next().unwrap_or(loc))
	636	+	}
	637	+	_ => message.to_string(),
	638	+	};
	639	+	if let Some(start) = s.find(", expected one of") {
	640	+	let end = s[start..]
	641	+	.find("; did you mean")
	642	+	.map_or(s.len(), \|i\| start + i);
	643	+	s.replace_range(start..end, "");
	644	+	}
	645	+	s
	646	+	}
	647	+
	648	+	fn keymap(layers: &[KeyTables]) -> Keymap {
	649	+	let refs: Vec<&KeyTables> = layers.iter().collect();
	650	+	Keymap::new(&refs)
	651	+	}
	652	+
	653	+	fn font_families(c: &Config) -> [String; 3] {
	654	+	[
	655	+	c.ui.font_ui.clone(),
	656	+	c.ui.font_mono.clone(),
	657	+	c.ui.font_display.clone(),
	658	+	]
	659	+	}
	660	+
387	661		fn lock<T>(m: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
388	662		m.lock().unwrap_or_else(\|e\| e.into_inner())
389	663		}
		@@ -420,7 +694,7 @@ impl ApplicationHandler<UserEvent> for App {
420	694		let mut attrs = Window::default_attributes()
421	695		.with_title("remage")
422	696		.with_inner_size(LogicalSize::new(w, h))
423		−	.with_decorations(false)
	697	+	.with_decorations(self.config.window.decorations)
424	698		.with_visible(false);
425	699		if self.opts.fullscreen {
426	700		attrs = attrs.with_fullscreen(Some(Fullscreen::Borderless(None)));
		@@ -442,7 +716,10 @@ impl ApplicationHandler<UserEvent> for App {
442	716		}
443	717		};
444	718		let renderer = match Renderer::new(window.clone(), event_loop.owned_display_handle()) {
445		−	Ok(r) => r,
	719	+	Ok(mut r) => {
	720	+	r.set_font_families(font_families(&self.config));
	721	+	r
	722	+	}
446	723		Err(e) => {
447	724		self.error = Some(e.context("initialise GPU"));
448	725		event_loop.exit();
		@@ -477,11 +754,24 @@ impl ApplicationHandler<UserEvent> for App {
477	754		g.window.request_redraw();
478	755		}
479	756		}
	757	+	UserEvent::Config(result) => match *result {
	758	+	Ok(loaded) => {
	759	+	log::info!("config reloaded");
	760	+	self.apply_config(loaded);
	761	+	}
	762	+	Err(e) => {
	763	+	log::error!("{e}");
	764	+	self.config_failed(&e.message);
	765	+	}
	766	+	},
	767	+	UserEvent::Sorted(files) => {
	768	+	self.state.queue.reorder(files);
	769	+	self.sync(false);
	770	+	}
480	771		}
481	772		}
482	773
483	774		fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
484		−	let now = Instant::now();
485	775		match event {
486	776		WindowEvent::CloseRequested => event_loop.exit(),
487	777		WindowEvent::Resized(size) => {
		@@ -521,22 +811,35 @@ impl ApplicationHandler<UserEvent> for App {
521	811		}
522	812		self.cursor = p;
523	813		}
524		−	WindowEvent::MouseInput {
525		−	state,
526		−	button: MouseButton::Left,
527		−	..
528		−	} => {
529		−	self.dragging = state == ElementState::Pressed;
	814	+	WindowEvent::MouseInput { state, button, .. } => {
	815	+	let pressed = state == ElementState::Pressed;
	816	+	if button == MouseButton::Left {
	817	+	// Drag pans; a press and release in place is a `<LeftMouse>` click.
	818	+	self.dragging = pressed;
	819	+	if pressed {
	820	+	self.press = Some(self.cursor);
	821	+	return;
	822	+	}
	823	+	let Some(p) = self.press.take() else { return };
	824	+	let moved = (self.cursor[0] - p[0]).hypot(self.cursor[1] - p[1]);
	825	+	if moved > CLICK_SLOP * self.state.scale_factor() {
	826	+	return;
	827	+	}
	828	+	} else if !pressed {
	829	+	return;
	830	+	}
	831	+	if let Some(key) = input::button(button, self.modifiers) {
	832	+	self.on_mouse_key(key, event_loop);
	833	+	}
530	834		}
531	835		WindowEvent::MouseWheel { delta, .. } => {
532		−	let steps = match delta {
533		−	MouseScrollDelta::LineDelta(_, y) => y,
534		−	MouseScrollDelta::PixelDelta(p) => p.y as f32 / PIXELS_PER_STEP,
	836	+	let d = match delta {
	837	+	MouseScrollDelta::LineDelta(x, y) => [x, y],
	838	+	MouseScrollDelta::PixelDelta(p) => {
	839	+	[p.x as f32 / PIXELS_PER_STEP, p.y as f32 / PIXELS_PER_STEP]
	840	+	}
535	841		};
536		−	if steps != 0.0 {
537		−	self.state.zoom_at(steps, self.cursor, now);
538		−	self.request_redraw();
539		−	}
	842	+	self.on_wheel(d, event_loop);
540	843		}
541	844		_ => {}
542	845		}
		@@ -551,7 +854,20 @@ impl ApplicationHandler<UserEvent> for App {
551	854		fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
552	855		let now = Instant::now();
553	856		let busy = self.pump_uploads();
	857	+	if let Some(t) = self.ambiguous_since
	858	+	&& now >= t + SEQUENCE_TIMEOUT
	859	+	{
	860	+	let runs = self.keymap.timeout(self.state.mode);
	861	+	self.update_pending(now);
	862	+	for run in runs {
	863	+	self.run(run.counted(), None, event_loop);
	864	+	}
	865	+	}
554	866		let (redraw, mut next) = self.state.tick(now);
	867	+	if let Some(t) = self.ambiguous_since {
	868	+	let at = t + SEQUENCE_TIMEOUT;
	869	+	next = Some(next.map_or(at, \|n\| n.min(at)));
	870	+	}
555	871		if redraw {
556	872		self.request_redraw();
557	873		}
		@@ -566,3 +882,23 @@ impl ApplicationHandler<UserEvent> for App {
566	882		});
567	883		}
568	884		}
	885	+
	886	+	#[cfg(test)]
	887	+	mod tests {
	888	+	use super::*;
	889	+
	890	+	#[test]
	891	+	fn config_errors_are_shortened_for_the_bar() {
	892	+	assert_eq!(
	893	+	short_error(
	894	+	"/home/u/.config/remage/config.toml:2:1: unknown field `fitt`, expected one of \
	895	+	`fit`, `zoom_step`; did you mean `fit`?"
	896	+	),
	897	+	"config.toml:2:1: unknown field `fitt`; did you mean `fit`?"
	898	+	);
	899	+	assert_eq!(
	900	+	short_error("a.toml:1:1: unknown field `x`, expected `y`"),
	901	+	"a.toml:1:1: unknown field `x`, expected `y`"
	902	+	);
	903	+	}
	904	+	}

		@@ -28,6 +28,11 @@ impl ImageCache {
28	28		}
29	29		}
30	30
	31	+	/// Takes effect at the next insert.
	32	+	pub fn set_budget(&mut self, budget_bytes: usize) {
	33	+	self.budget = budget_bytes;
	34	+	}
	35	+
31	36		pub fn get(&mut self, path: &Path) -> Option<Arc<DecodedImage>> {
32	37		self.clock += 1;
33	38		let slot = self.map.get_mut(path)?;

		@@ -1,4 +1,8 @@
1		−	//! Colour tokens, presets and palette derivation.
	1	+	//! Colour tokens, presets, palette derivation and pywal import.
	2	+
	3	+	use std::path::Path;
	4	+
	5	+	use serde::{Deserialize, Deserializer, Serialize, Serializer};
2	6
3	7		/// An sRGB colour with straight alpha.
4	8		#[derive(Clone, Copy, Debug, PartialEq, Eq)]
		@@ -36,24 +40,131 @@ impl Rgba {
36	40		self.0[3] as f32 / 255.0,
37	41		]
38	42		}
	43	+
	44	+	/// `#RGB`, `#RRGGBB` or `#RRGGBBAA`; the `#` is optional.
	45	+	pub fn parse(s: &str) -> Result<Rgba, String> {
	46	+	let hex = s.trim().strip_prefix('#').unwrap_or(s.trim());
	47	+	let bad = \|\| format!("expected a colour like \"#D71921\", got \"{s}\"");
	48	+	if !hex.chars().all(\|c\| c.is_ascii_hexdigit()) {
	49	+	return Err(bad());
	50	+	}
	51	+	let byte = \|i: usize\| u8::from_str_radix(&hex[i..i + 2], 16).map_err(\|_\| bad());
	52	+	match hex.len() {
	53	+	3 => {
	54	+	let n = \|i: usize\| u8::from_str_radix(&hex[i..=i], 16).map(\|v\| v * 17);
	55	+	Ok(Rgba([
	56	+	n(0).map_err(\|_\| bad())?,
	57	+	n(1).map_err(\|_\| bad())?,
	58	+	n(2).map_err(\|_\| bad())?,
	59	+	255,
	60	+	]))
	61	+	}
	62	+	6 => Ok(Rgba([byte(0)?, byte(2)?, byte(4)?, 255])),
	63	+	8 => Ok(Rgba([byte(0)?, byte(2)?, byte(4)?, byte(6)?])),
	64	+	_ => Err(bad()),
	65	+	}
	66	+	}
	67	+	}
	68	+
	69	+	impl std::fmt::Display for Rgba {
	70	+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
	71	+	let [r, g, b, a] = self.0;
	72	+	if a == 255 {
	73	+	write!(f, "#{r:02X}{g:02X}{b:02X}")
	74	+	} else {
	75	+	write!(f, "#{r:02X}{g:02X}{b:02X}{a:02X}")
	76	+	}
	77	+	}
	78	+	}
	79	+
	80	+	impl<'de> Deserialize<'de> for Rgba {
	81	+	fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
	82	+	let s = String::deserialize(d)?;
	83	+	Rgba::parse(&s).map_err(serde::de::Error::custom)
	84	+	}
	85	+	}
	86	+
	87	+	impl Serialize for Rgba {
	88	+	fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
	89	+	s.serialize_str(&self.to_string())
	90	+	}
	91	+	}
	92	+
	93	+	/// Generates the token struct, the optional overrides in `[theme]`, and per-token helpers.
	94	+	macro_rules! tokens {
	95	+	($($name:ident),* $(,)?) => {
	96	+	#[derive(Clone, Debug, PartialEq)]
	97	+	pub struct Theme {
	98	+	$(pub $name: Rgba,)*
	99	+	}
	100	+
	101	+	#[derive(Clone, Debug, Default, PartialEq, Deserialize)]
	102	+	#[serde(default, deny_unknown_fields)]
	103	+	pub struct ThemeConfig {
	104	+	pub preset: Preset,
	105	+	/// pywal's `colors.json`.
	106	+	pub pywal: Option<String>,
	107	+	$(pub $name: Option<Rgba>,)*
	108	+	}
	109	+
	110	+	impl Theme {
	111	+	/// Every token mixed from `self` (t = 0) to `other` (t = 1).
	112	+	pub fn mix(&self, other: &Theme, t: f32) -> Theme {
	113	+	Theme {
	114	+	$($name: other.$name.mix_over(self.$name, t),)*
	115	+	}
	116	+	}
	117	+
	118	+	fn apply(&mut self, cfg: &ThemeConfig) {
	119	+	$(if let Some(c) = cfg.$name {
	120	+	self.$name = c;
	121	+	})*
	122	+	}
	123	+	}
	124	+	};
39	125		}
40	126
41		−	#[derive(Clone, Debug, PartialEq)]
42		−	pub struct Theme {
43		−	pub background: Rgba,
44		−	pub foreground: Rgba,
45		−	pub surface: Rgba,
46		−	pub surface_raised: Rgba,
47		−	pub border: Rgba,
48		−	pub border_visible: Rgba,
49		−	pub text_disabled: Rgba,
50		−	pub text_secondary: Rgba,
51		−	pub text_primary: Rgba,
52		−	pub text_display: Rgba,
53		−	pub accent: Rgba,
54		−	pub success: Rgba,
55		−	pub warning: Rgba,
56		−	pub image_background: Rgba,
	127	+	tokens!(
	128	+	background,
	129	+	foreground,
	130	+	surface,
	131	+	surface_raised,
	132	+	border,
	133	+	border_visible,
	134	+	text_disabled,
	135	+	text_secondary,
	136	+	text_primary,
	137	+	text_display,
	138	+	accent,
	139	+	success,
	140	+	warning,
	141	+	image_background,
	142	+	);
	143	+
	144	+	#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize, Serialize)]
	145	+	#[serde(rename_all = "kebab-case")]
	146	+	pub enum Preset {
	147	+	#[default]
	148	+	NothingDark,
	149	+	NothingLight,
	150	+	}
	151	+
	152	+	impl Preset {
	153	+	/// Background, foreground, accent.
	154	+	fn colors(self) -> [Rgba; 3] {
	155	+	match self {
	156	+	Preset::NothingDark => [
	157	+	Rgba::rgb(0x000000),
	158	+	Rgba::rgb(0xFFFFFF),
	159	+	Rgba::rgb(0xD71921),
	160	+	],
	161	+	Preset::NothingLight => [
	162	+	Rgba::rgb(0xF5F5F5),
	163	+	Rgba::rgb(0x000000),
	164	+	Rgba::rgb(0xD71921),
	165	+	],
	166	+	}
	167	+	}
57	168		}
58	169
59	170		impl Theme {
		@@ -80,14 +191,41 @@ impl Theme {
80	191		}
81	192
82	193		pub fn nothing_dark() -> Self {
83		−	Self::derive(
84		−	Rgba::rgb(0x000000),
85		−	Rgba::rgb(0xFFFFFF),
86		−	Rgba::rgb(0xD71921),
87		−	)
	194	+	let [bg, fg, accent] = Preset::NothingDark.colors();
	195	+	Self::derive(bg, fg, accent)
88	196		}
89	197		}
90	198
	199	+	/// Preset, then pywal, then explicit base colours; derive the rest, then explicit tokens win.
	200	+	/// `image_background` follows the final background unless set.
	201	+	pub fn resolve(cfg: &ThemeConfig, pywal: Option<[Rgba; 3]>) -> Theme {
	202	+	let [mut bg, mut fg, mut accent] = pywal.unwrap_or_else(\|\| cfg.preset.colors());
	203	+	bg = cfg.background.unwrap_or(bg);
	204	+	fg = cfg.foreground.unwrap_or(fg);
	205	+	accent = cfg.accent.unwrap_or(accent);
	206	+	let mut theme = Theme::derive(bg, fg, accent);
	207	+	theme.apply(cfg);
	208	+	theme
	209	+	}
	210	+
	211	+	/// Background, foreground and accent from pywal's `colors.json`.
	212	+	pub fn read_pywal(path: &Path) -> Result<[Rgba; 3], String> {
	213	+	let src = std::fs::read_to_string(path).map_err(\|e\| format!("{}: {e}", path.display()))?;
	214	+	let json: serde_json::Value =
	215	+	serde_json::from_str(&src).map_err(\|e\| format!("{}: {e}", path.display()))?;
	216	+	let get = \|a: &str, b: &str\| -> Result<Rgba, String> {
	217	+	let s = json[a][b]
	218	+	.as_str()
	219	+	.ok_or_else(\|\| format!("{}: missing {a}.{b}", path.display()))?;
	220	+	Rgba::parse(s).map_err(\|e\| format!("{}: {a}.{b}: {e}", path.display()))
	221	+	};
	222	+	Ok([
	223	+	get("special", "background")?,
	224	+	get("special", "foreground")?,
	225	+	get("colors", "color1")?,
	226	+	])
	227	+	}
	228	+
91	229		#[cfg(test)]
92	230		mod tests {
93	231		use super::*;
		@@ -112,4 +250,81 @@ mod tests {
112	250		let mid = Rgba::rgb(0x808080).linear()[0];
113	251		assert!((mid - 0.2158).abs() < 1e-3);
114	252		}
	253	+
	254	+	#[test]
	255	+	fn hex_parsing() {
	256	+	assert_eq!(Rgba::parse("#D71921"), Ok(Rgba::rgb(0xD71921)));
	257	+	assert_eq!(Rgba::parse("d71921"), Ok(Rgba::rgb(0xD71921)));
	258	+	assert_eq!(Rgba::parse("#fff"), Ok(Rgba::rgb(0xFFFFFF)));
	259	+	assert_eq!(Rgba::parse("#00000080"), Ok(Rgba([0, 0, 0, 0x80])));
	260	+	assert!(Rgba::parse("#12345").is_err());
	261	+	assert!(Rgba::parse("#gggggg").is_err());
	262	+	assert!(Rgba::parse("#ÿÿÿ").is_err());
	263	+	assert_eq!(Rgba::rgb(0xD71921).to_string(), "#D71921");
	264	+	}
	265	+
	266	+	#[test]
	267	+	fn resolution_order() {
	268	+	let mut cfg = ThemeConfig::default();
	269	+	assert_eq!(resolve(&cfg, None), Theme::nothing_dark());
	270	+	cfg.preset = Preset::NothingLight;
	271	+	let light = resolve(&cfg, None);
	272	+	assert_eq!(light.background, Rgba::rgb(0xF5F5F5));
	273	+	assert_eq!(light.image_background, Rgba::rgb(0xF5F5F5));
	274	+	assert_eq!(light.text_display, Rgba::rgb(0x000000));
	275	+	// pywal replaces the preset; explicit colours win over pywal.
	276	+	let wal = [
	277	+	Rgba::rgb(0x102030),
	278	+	Rgba::rgb(0xF0E0D0),
	279	+	Rgba::rgb(0x00FF00),
	280	+	];
	281	+	cfg.accent = Some(Rgba::rgb(0x0000FF));
	282	+	cfg.border = Some(Rgba::rgb(0x123456));
	283	+	let t = resolve(&cfg, Some(wal));
	284	+	assert_eq!(t.background, Rgba::rgb(0x102030));
	285	+	assert_eq!(t.accent, Rgba::rgb(0x0000FF));
	286	+	assert_eq!(t.border, Rgba::rgb(0x123456));
	287	+	assert_eq!(
	288	+	t.surface,
	289	+	Rgba::rgb(0xF0E0D0).mix_over(Rgba::rgb(0x102030), 0.067)
	290	+	);
	291	+	}
	292	+
	293	+	#[test]
	294	+	fn mixing_themes() {
	295	+	let a = Theme::nothing_dark();
	296	+	let b = resolve(
	297	+	&ThemeConfig {
	298	+	preset: Preset::NothingLight,
	299	+	..Default::default()
	300	+	},
	301	+	None,
	302	+	);
	303	+	assert_eq!(a.mix(&b, 0.0), a);
	304	+	assert_eq!(a.mix(&b, 1.0), b);
	305	+	assert_eq!(a.mix(&b, 0.5).background, Rgba([123, 123, 123, 255]));
	306	+	}
	307	+
	308	+	#[test]
	309	+	fn pywal_import() {
	310	+	let dir = std::env::temp_dir().join(format!("remage-wal-{}", std::process::id()));
	311	+	std::fs::create_dir_all(&dir).unwrap();
	312	+	let p = dir.join("colors.json");
	313	+	std::fs::write(
	314	+	&p,
	315	+	r##"{"special":{"background":"#0b0c10","foreground":"#c5c6c7","cursor":"#c5c6c7"},
	316	+	"colors":{"color0":"#0b0c10","color1":"#66fcf1"}}"##,
	317	+	)
	318	+	.unwrap();
	319	+	assert_eq!(
	320	+	read_pywal(&p),
	321	+	Ok([
	322	+	Rgba::rgb(0x0B0C10),
	323	+	Rgba::rgb(0xC5C6C7),
	324	+	Rgba::rgb(0x66FCF1)
	325	+	])
	326	+	);
	327	+	std::fs::write(&p, "{}").unwrap();
	328	+	assert!(read_pywal(&p).unwrap_err().contains("special.background"));
	329	+	}
115	330		}

	@@ -0,0 +1,143 @@
1	+	//! Live reload: a background thread that reloads the config when a watched file changes, on
2	+	//! SIGUSR1, or on request, and hands the result to the event loop.
3	+
4	+	use std::collections::HashSet;
5	+	use std::path::{Path, PathBuf};
6	+	use std::time::Duration;
7	+
8	+	use crossbeam_channel::{Receiver, RecvTimeoutError, Sender};
9	+	use notify::event::{AccessKind, AccessMode};
10	+	use notify::{EventKind, RecommendedWatcher, RecursiveMode, Watcher};
11	+
12	+	use super::{LoadError, Loaded, load};
13	+
14	+	/// Quiet time before reloading, so editors' multi-step saves reload once.
15	+	const DEBOUNCE: Duration = Duration::from_millis(100);
16	+
17	+	enum Msg {
18	+	Fs(notify::Event),
19	+	Reload,
20	+	}
21	+
22	+	/// Handle to the reload thread. Dropping it stops nothing; the thread lives with the process.
23	+	#[derive(Clone)]
24	+	pub struct ConfigWatch {
25	+	tx: Sender<Msg>,
26	+	}
27	+
28	+	impl ConfigWatch {
29	+	/// Reload now (the `reload-config` action).
30	+	pub fn reload(&self) {
31	+	let _ = self.tx.send(Msg::Reload);
32	+	}
33	+	}
34	+
35	+	/// Start watching `watch` (from the initial load); `deliver` receives every reload result.
36	+	pub fn spawn(
37	+	path: Option<PathBuf>,
38	+	watch: Vec<PathBuf>,
39	+	deliver: impl Fn(Result<Loaded, LoadError>) + Send + 'static,
40	+	) -> ConfigWatch {
41	+	let (tx, rx) = crossbeam_channel::unbounded();
42	+	let fs_tx = tx.clone();
43	+	let sig_tx = tx.clone();
44	+	std::thread::Builder::new()
45	+	.name("remage-sigusr1".into())
46	+	.spawn(
47	+	move \|\| match signal_hook::iterator::Signals::new([signal_hook::consts::SIGUSR1]) {
48	+	Ok(mut signals) => {
49	+	for _ in signals.forever() {
50	+	if sig_tx.send(Msg::Reload).is_err() {
51	+	break;
52	+	}
53	+	}
54	+	}
55	+	Err(e) => log::warn!("SIGUSR1 handler: {e}"),
56	+	},
57	+	)
58	+	.ok();
59	+	std::thread::Builder::new()
60	+	.name("remage-config".into())
61	+	.spawn(move \|\| {
62	+	let watcher = notify::recommended_watcher(move \|res: notify::Result<notify::Event>\| {
63	+	if let Ok(ev) = res {
64	+	let _ = fs_tx.send(Msg::Fs(ev));
65	+	}
66	+	});
67	+	let mut watcher = match watcher {
68	+	Ok(w) => Some(w),
69	+	Err(e) => {
70	+	log::warn!("config watcher: {e}");
71	+	None
72	+	}
73	+	};
74	+	run(path.as_deref(), watch, &rx, watcher.as_mut(), deliver);
75	+	})
76	+	.ok();
77	+	ConfigWatch { tx }
78	+	}
79	+
80	+	fn run(
81	+	path: Option<&Path>,
82	+	mut files: Vec<PathBuf>,
83	+	rx: &Receiver<Msg>,
84	+	mut watcher: Option<&mut RecommendedWatcher>,
85	+	deliver: impl Fn(Result<Loaded, LoadError>),
86	+	) {
87	+	let mut dirs = HashSet::new();
88	+	if let Some(w) = watcher.as_deref_mut() {
89	+	watch_dirs(w, &mut dirs, &files);
90	+	}
91	+	while let Ok(msg) = rx.recv() {
92	+	if let Msg::Fs(ev) = &msg
93	+	&& !relevant(ev, &files)
94	+	{
95	+	continue;
96	+	}
97	+	loop {
98	+	match rx.recv_timeout(DEBOUNCE) {
99	+	Ok(_) => continue,
100	+	Err(RecvTimeoutError::Timeout) => break,
101	+	Err(RecvTimeoutError::Disconnected) => return,
102	+	}
103	+	}
104	+	let result = load(path);
105	+	files = match &result {
106	+	Ok(l) => l.watch.clone(),
107	+	Err(e) => e.watch.clone(),
108	+	};
109	+	if let Some(w) = watcher.as_deref_mut() {
110	+	watch_dirs(w, &mut dirs, &files);
111	+	}
112	+	deliver(result);
113	+	}
114	+	}
115	+
116	+	/// Watch the parent directory of every file: editors replace files by renaming, which a
117	+	/// watch on the file itself would lose.
118	+	fn watch_dirs(w: &mut RecommendedWatcher, dirs: &mut HashSet<PathBuf>, files: &[PathBuf]) {
119	+	let wanted: HashSet<PathBuf> = files
120	+	.iter()
121	+	.filter_map(\|f\| f.parent())
122	+	.filter(\|d\| d.is_dir())
123	+	.map(Path::to_path_buf)
124	+	.collect();
125	+	for d in dirs.difference(&wanted) {
126	+	let _ = w.unwatch(d);
127	+	}
128	+	for d in wanted.difference(dirs) {
129	+	if let Err(e) = w.watch(d, RecursiveMode::NonRecursive) {
130	+	log::warn!("watch {}: {e}", d.display());
131	+	}
132	+	}
133	+	*dirs = wanted;
134	+	}
135	+
136	+	fn relevant(ev: &notify::Event, files: &[PathBuf]) -> bool {
137	+	let changes = match ev.kind {
138	+	EventKind::Access(AccessKind::Close(AccessMode::Write)) => true,
139	+	EventKind::Access(_) => false,
140	+	_ => true,
141	+	};
142	+	changes && ev.paths.iter().any(\|p\| files.iter().any(\|f\| f == p))
143	+	}

		@@ -1 +1,436 @@
1	1		//! Per-mode key trie: pending sequences, counts and which-key candidates.
	2	+
	3	+	use std::collections::BTreeMap;
	4	+
	5	+	use super::keys::{Key, KeySeq};
	6	+	use crate::action::Action;
	7	+	use crate::state::Mode;
	8	+
	9	+	/// Bindings from one config layer, in file order. `None` is `"none"`: remove the binding.
	10	+	pub type Bindings = Vec<(KeySeq, Option<Vec<Action>>)>;
	11	+
	12	+	/// One layer's `[keys.*]` tables.
	13	+	#[derive(Clone, Debug, Default, PartialEq)]
	14	+	pub struct KeyTables {
	15	+	pub global: Bindings,
	16	+	pub image: Bindings,
	17	+	pub grid: Bindings,
	18	+	pub visual: Bindings,
	19	+	}
	20	+
	21	+	/// A completed binding: the actions to run and the count typed before it.
	22	+	#[derive(Clone, Debug, PartialEq)]
	23	+	pub struct Run {
	24	+	pub actions: Vec<Action>,
	25	+	pub count: Option<usize>,
	26	+	}
	27	+
	28	+	impl Run {
	29	+	/// The actions with the count applied.
	30	+	pub fn counted(self) -> Vec<Action> {
	31	+	match self.count {
	32	+	Some(n) => self.actions.into_iter().map(\|a\| a.with_count(n)).collect(),
	33	+	None => self.actions,
	34	+	}
	35	+	}
	36	+	}
	37	+
	38	+	/// A next key that would continue the pending sequence.
	39	+	#[allow(dead_code)] // which-key arrives in M6
	40	+	#[derive(Clone, Debug, PartialEq)]
	41	+	pub struct Candidate {
	42	+	pub key: Key,
	43	+	pub actions: Option<Vec<Action>>,
	44	+	/// Longer sequences continue through this key.
	45	+	pub prefix: bool,
	46	+	}
	47	+
	48	+	#[derive(Clone, Debug, Default)]
	49	+	struct Node {
	50	+	actions: Option<Vec<Action>>,
	51	+	children: BTreeMap<Key, Node>,
	52	+	}
	53	+
	54	+	impl Node {
	55	+	fn walk(&self, keys: &[Key]) -> Option<&Node> {
	56	+	keys.iter().try_fold(self, \|n, k\| n.children.get(k))
	57	+	}
	58	+
	59	+	fn insert(&mut self, keys: &[Key], actions: Vec<Action>) {
	60	+	let node = keys
	61	+	.iter()
	62	+	.fold(self, \|n, k\| n.children.entry(*k).or_default());
	63	+	node.actions = Some(actions);
	64	+	}
	65	+
	66	+	fn collect(&self, prefix: &mut Vec<Key>, out: &mut Vec<(KeySeq, Vec<Action>)>) {
	67	+	if let Some(a) = &self.actions {
	68	+	out.push((KeySeq(prefix.clone()), a.clone()));
	69	+	}
	70	+	for (k, child) in &self.children {
	71	+	prefix.push(*k);
	72	+	child.collect(prefix, out);
	73	+	prefix.pop();
	74	+	}
	75	+	}
	76	+	}
	77	+
	78	+	/// Largest count accepted; more digits are ignored.
	79	+	const MAX_COUNT: usize = 9_999_999;
	80	+
	81	+	#[derive(Clone, Debug, Default)]
	82	+	pub struct Keymap {
	83	+	/// Image, grid, visual.
	84	+	tries: [Node; 3],
	85	+	pending: Vec<Key>,
	86	+	count: Option<usize>,
	87	+	}
	88	+
	89	+	fn idx(mode: Mode) -> usize {
	90	+	match mode {
	91	+	Mode::Image => 0,
	92	+	Mode::Grid => 1,
	93	+	Mode::Visual => 2,
	94	+	}
	95	+	}
	96	+
	97	+	impl Keymap {
	98	+	/// Build from config layers, lowest priority first. Within each mode the levels stack
	99	+	/// global < mode (< visual for visual mode, which sits on grid); later layers win inside a
	100	+	/// level, and `"none"` removes whatever a lower level bound.
	101	+	pub fn new(layers: &[&KeyTables]) -> Self {
	102	+	type Level = fn(&KeyTables) -> &Bindings;
	103	+	let global: Level = \|t\| &t.global;
	104	+	let image: Level = \|t\| &t.image;
	105	+	let grid: Level = \|t\| &t.grid;
	106	+	let visual: Level = \|t\| &t.visual;
	107	+	let chains: [&[Level]; 3] = [&[global, image], &[global, grid], &[global, grid, visual]];
	108	+	let mut km = Keymap::default();
	109	+	for (trie, chain) in km.tries.iter_mut().zip(chains) {
	110	+	let mut flat: BTreeMap<&KeySeq, &Vec<Action>> = BTreeMap::new();
	111	+	for level in chain {
	112	+	let mut merged: BTreeMap<&KeySeq, Option<&Vec<Action>>> = BTreeMap::new();
	113	+	for layer in layers {
	114	+	for (k, v) in level(layer) {
	115	+	merged.insert(k, v.as_ref());
	116	+	}
	117	+	}
	118	+	for (k, v) in merged {
	119	+	match v {
	120	+	Some(a) => flat.insert(k, a),
	121	+	None => flat.remove(k),
	122	+	};
	123	+	}
	124	+	}
	125	+	for (k, a) in flat {
	126	+	trie.insert(&k.0, a.clone());
	127	+	}
	128	+	}
	129	+	km
	130	+	}
	131	+
	132	+	fn root(&self, mode: Mode) -> &Node {
	133	+	&self.tries[idx(mode)]
	134	+	}
	135	+
	136	+	/// Feed one key press. Returns the bindings it completed (usually none or one; an
	137	+	/// ambiguous prefix followed by a non-continuing key yields the prefix's binding first).
	138	+	pub fn feed(&mut self, mode: Mode, key: Key) -> Vec<Run> {
	139	+	if self.pending.is_empty()
	140	+	&& let Some(d) = key.digit()
	141	+	&& (d != 0 \|\| self.count.is_some())
	142	+	{
	143	+	let c = self.count.unwrap_or(0).saturating_mul(10) + d as usize;
	144	+	self.count = Some(c.min(MAX_COUNT));
	145	+	return Vec::new();
	146	+	}
	147	+	self.pending.push(key);
	148	+	match self.root(mode).walk(&self.pending) {
	149	+	Some(node) if node.children.is_empty() => {
	150	+	let actions = node.actions.clone().unwrap_or_default();
	151	+	self.pending.clear();
	152	+	vec![Run {
	153	+	actions,
	154	+	count: self.count.take(),
	155	+	}]
	156	+	}
	157	+	Some(_) => Vec::new(),
	158	+	None => {
	159	+	self.pending.pop();
	160	+	let prefix = self
	161	+	.root(mode)
	162	+	.walk(&self.pending)
	163	+	.and_then(\|n\| n.actions.clone())
	164	+	.filter(\|_\| !self.pending.is_empty());
	165	+	self.pending.clear();
	166	+	match prefix {
	167	+	// `g` is bound and so is `gg`: `gx` runs `g`, then `x` on its own.
	168	+	Some(actions) => {
	169	+	let mut out = vec![Run {
	170	+	actions,
	171	+	count: self.count.take(),
	172	+	}];
	173	+	out.extend(self.feed(mode, key));
	174	+	out
	175	+	}
	176	+	None => {
	177	+	self.count = None;
	178	+	Vec::new()
	179	+	}
	180	+	}
	181	+	}
	182	+	}
	183	+	}
	184	+
	185	+	/// The pending sequence is itself bound and also a prefix of longer ones.
	186	+	pub fn is_ambiguous(&self, mode: Mode) -> bool {
	187	+	!self.pending.is_empty()
	188	+	&& self
	189	+	.root(mode)
	190	+	.walk(&self.pending)
	191	+	.is_some_and(\|n\| n.actions.is_some() && !n.children.is_empty())
	192	+	}
	193	+
	194	+	/// The user stopped typing: an ambiguous sequence runs its own binding.
	195	+	pub fn timeout(&mut self, mode: Mode) -> Vec<Run> {
	196	+	if !self.is_ambiguous(mode) {
	197	+	return Vec::new();
	198	+	}
	199	+	let actions = self
	200	+	.root(mode)
	201	+	.walk(&self.pending)
	202	+	.and_then(\|n\| n.actions.clone())
	203	+	.unwrap_or_default();
	204	+	self.pending.clear();
	205	+	vec![Run {
	206	+	actions,
	207	+	count: self.count.take(),
	208	+	}]
	209	+	}
	210	+
	211	+	/// A key sequence (not a count) is waiting for more keys.
	212	+	#[allow(dead_code)] // which-key arrives in M6
	213	+	pub fn is_pending(&self) -> bool {
	214	+	!self.pending.is_empty()
	215	+	}
	216	+
	217	+	pub fn cancel(&mut self) {
	218	+	self.pending.clear();
	219	+	self.count = None;
	220	+	}
	221	+
	222	+	/// The count and keys typed so far, for the status bar.
	223	+	pub fn pending_display(&self) -> String {
	224	+	let mut s = self.count.map(\|c\| c.to_string()).unwrap_or_default();
	225	+	if !self.pending.is_empty() {
	226	+	s.push_str(&KeySeq(self.pending.clone()).to_string());
	227	+	}
	228	+	s
	229	+	}
	230	+
	231	+	/// The binding of a complete sequence (mouse buttons and the wheel bypass the trie).
	232	+	pub fn lookup(&self, mode: Mode, keys: &[Key]) -> Option<&[Action]> {
	233	+	self.root(mode).walk(keys)?.actions.as_deref()
	234	+	}
	235	+
	236	+	/// The keys that continue the pending sequence, for which-key.
	237	+	#[allow(dead_code)] // which-key arrives in M6
	238	+	pub fn candidates(&self, mode: Mode) -> Vec<Candidate> {
	239	+	let Some(node) = self.root(mode).walk(&self.pending) else {
	240	+	return Vec::new();
	241	+	};
	242	+	node.children
	243	+	.iter()
	244	+	.map(\|(k, n)\| Candidate {
	245	+	key: *k,
	246	+	actions: n.actions.clone(),
	247	+	prefix: !n.children.is_empty(),
	248	+	})
	249	+	.collect()
	250	+	}
	251	+
	252	+	/// Every binding in a mode, in key order.
	253	+	pub fn bindings(&self, mode: Mode) -> Vec<(KeySeq, Vec<Action>)> {
	254	+	let mut out = Vec::new();
	255	+	self.root(mode).collect(&mut Vec::new(), &mut out);
	256	+	out
	257	+	}
	258	+
	259	+	/// The sequences bound to exactly `action` in a mode, shortest first.
	260	+	#[allow(dead_code)] // the palette and help arrive in M6
	261	+	pub fn keys_for(&self, mode: Mode, action: &Action) -> Vec<KeySeq> {
	262	+	let mut keys: Vec<KeySeq> = self
	263	+	.bindings(mode)
	264	+	.into_iter()
	265	+	.filter(\|(_, a)\| a.len() == 1 && a[0] == *action)
	266	+	.map(\|(k, _)\| k)
	267	+	.collect();
	268	+	keys.sort_by_key(\|k\| k.0.len());
	269	+	keys
	270	+	}
	271	+	}
	272	+
	273	+	#[cfg(test)]
	274	+	mod tests {
	275	+	use super::*;
	276	+	use crate::action::Zoom;
	277	+
	278	+	fn bind(pairs: &[(&str, &str)]) -> Bindings {
	279	+	pairs
	280	+	.iter()
	281	+	.map(\|(k, a)\| {
	282	+	let actions = (*a != "none").then(\|\| vec![a.parse().unwrap()]);
	283	+	(k.parse().unwrap(), actions)
	284	+	})
	285	+	.collect()
	286	+	}
	287	+
	288	+	fn keys(s: &str) -> Vec<Key> {
	289	+	s.parse::<KeySeq>().unwrap().0
	290	+	}
	291	+
	292	+	/// Feed a whole string and collect the counted actions.
	293	+	fn type_(km: &mut Keymap, mode: Mode, s: &str) -> Vec<Action> {
	294	+	keys(s)
	295	+	.into_iter()
	296	+	.flat_map(\|k\| km.feed(mode, k))
	297	+	.flat_map(Run::counted)
	298	+	.collect()
	299	+	}
	300	+
	301	+	fn defaults() -> KeyTables {
	302	+	KeyTables {
	303	+	global: bind(&[
	304	+	("n", "next"),
	305	+	("gg", "first"),
	306	+	("G", "last"),
	307	+	("q", "quit"),
	308	+	("0", "first"),
	309	+	("<Space>w", "run wallpaper"),
	310	+	("<Space>c", "run copy"),
	311	+	]),
	312	+	image: bind(&[("+", "zoom in"), ("h", "pan left")]),
	313	+	grid: bind(&[("h", "prev"), ("v", "visual")]),
	314	+	visual: bind(&[("m", "mark-all")]),
	315	+	}
	316	+	}
	317	+
	318	+	#[test]
	319	+	fn sequences_and_counts() {
	320	+	let t = defaults();
	321	+	let mut km = Keymap::new(&[&t]);
	322	+	let m = Mode::Image;
	323	+	assert_eq!(type_(&mut km, m, "n"), [Action::Next(1)]);
	324	+	assert_eq!(type_(&mut km, m, "g"), []);
	325	+	assert_eq!(km.pending_display(), "g");
	326	+	assert_eq!(type_(&mut km, m, "g"), [Action::First]);
	327	+	assert_eq!(type_(&mut km, m, "12G"), [Action::Goto(12)]);
	328	+	assert_eq!(type_(&mut km, m, "5gg"), [Action::Goto(5)]);
	329	+	assert_eq!(type_(&mut km, m, "3n"), [Action::Next(3)]);
	330	+	assert_eq!(type_(&mut km, m, "3+"), [Action::Zoom(Zoom::In(3))]);
	331	+	// `0` is a key unless a count is pending.
	332	+	assert_eq!(type_(&mut km, m, "0"), [Action::First]);
	333	+	assert_eq!(type_(&mut km, m, "10n"), [Action::Next(10)]);
	334	+	assert_eq!(km.pending_display(), "");
	335	+	}
	336	+
	337	+	#[test]
	338	+	fn broken_sequences_are_dropped() {
	339	+	let t = defaults();
	340	+	let mut km = Keymap::new(&[&t]);
	341	+	let m = Mode::Image;
	342	+	assert_eq!(type_(&mut km, m, "5gx"), []);
	343	+	assert!(!km.is_pending());
	344	+	assert_eq!(km.pending_display(), "");
	345	+	assert_eq!(type_(&mut km, m, "<Space>"), []);
	346	+	assert_eq!(type_(&mut km, m, "<Esc>"), []);
	347	+	assert_eq!(type_(&mut km, m, "n"), [Action::Next(1)]);
	348	+	assert_eq!(type_(&mut km, m, "Z"), []);
	349	+	}
	350	+
	351	+	#[test]
	352	+	fn modes_override_global() {
	353	+	let t = defaults();
	354	+	let mut km = Keymap::new(&[&t]);
	355	+	assert_eq!(
	356	+	type_(&mut km, Mode::Image, "h"),
	357	+	[Action::Pan(crate::state::view::Dir::Left)]
	358	+	);
	359	+	assert_eq!(type_(&mut km, Mode::Grid, "h"), [Action::Prev(1)]);
	360	+	// Visual sits on grid.
	361	+	assert_eq!(type_(&mut km, Mode::Visual, "h"), [Action::Prev(1)]);
	362	+	assert_eq!(type_(&mut km, Mode::Visual, "m"), [Action::MarkAll]);
	363	+	assert_eq!(type_(&mut km, Mode::Grid, "m"), []);
	364	+	}
	365	+
	366	+	#[test]
	367	+	fn later_layers_win_and_none_removes() {
	368	+	let base = defaults();
	369	+	let user = KeyTables {
	370	+	global: bind(&[("n", "prev"), ("q", "none")]),
	371	+	image: bind(&[("+", "none"), ("G", "none")]),
	372	+	..Default::default()
	373	+	};
	374	+	let mut km = Keymap::new(&[&base, &user]);
	375	+	assert_eq!(type_(&mut km, Mode::Image, "n"), [Action::Prev(1)]);
	376	+	assert_eq!(type_(&mut km, Mode::Image, "q"), []);
	377	+	assert_eq!(type_(&mut km, Mode::Image, "+"), []);
	378	+	// A mode's "none" masks the global binding in that mode only.
	379	+	assert_eq!(type_(&mut km, Mode::Image, "G"), []);
	380	+	assert_eq!(type_(&mut km, Mode::Grid, "G"), [Action::Last]);
	381	+	}
	382	+
	383	+	#[test]
	384	+	fn ambiguous_prefix_waits_then_resolves() {
	385	+	let t = KeyTables {
	386	+	global: bind(&[("g", "first"), ("gg", "last"), ("n", "next")]),
	387	+	..Default::default()
	388	+	};
	389	+	let mut km = Keymap::new(&[&t]);
	390	+	let m = Mode::Image;
	391	+	assert_eq!(type_(&mut km, m, "g"), []);
	392	+	assert!(km.is_ambiguous(m));
	393	+	assert_eq!(type_(&mut km, m, "g"), [Action::Last]);
	394	+	// A non-continuing key runs the prefix, then itself.
	395	+	assert_eq!(type_(&mut km, m, "gn"), [Action::First, Action::Next(1)]);
	396	+	type_(&mut km, m, "4g");
	397	+	let fired: Vec<Action> = km.timeout(m).into_iter().flat_map(Run::counted).collect();
	398	+	assert_eq!(fired, [Action::Goto(4)]);
	399	+	assert!(!km.is_pending());
	400	+	}
	401	+
	402	+	#[test]
	403	+	fn which_key_candidates() {
	404	+	let t = defaults();
	405	+	let mut km = Keymap::new(&[&t]);
	406	+	type_(&mut km, Mode::Image, "<Space>");
	407	+	let c = km.candidates(Mode::Image);
	408	+	assert_eq!(c.len(), 2);
	409	+	assert_eq!(c[0].key, Key::plain('c'));
	410	+	assert_eq!(c[0].actions, Some(vec![Action::Run("copy".into())]));
	411	+	assert!(!c[0].prefix);
	412	+	km.cancel();
	413	+	let root = km.candidates(Mode::Image);
	414	+	assert!(root.iter().any(\|c\| c.key == Key::plain('g') && c.prefix));
	415	+	}
	416	+
	417	+	#[test]
	418	+	fn lookup_and_reverse_lookup() {
	419	+	let t = defaults();
	420	+	let km = Keymap::new(&[&t]);
	421	+	assert_eq!(
	422	+	km.lookup(Mode::Image, &keys("n")),
	423	+	Some(&[Action::Next(1)][..])
	424	+	);
	425	+	assert_eq!(km.lookup(Mode::Image, &keys("g")), None);
	426	+	assert_eq!(
	427	+	km.keys_for(Mode::Image, &Action::First),
	428	+	vec!["0".parse().unwrap(), "gg".parse().unwrap()]
	429	+	);
	430	+	assert!(
	431	+	km.bindings(Mode::Grid)
	432	+	.iter()
	433	+	.any(\|(k, _)\| k.to_string() == "v")
	434	+	);
	435	+	}
	436	+	}

		@@ -1 +1,437 @@
1		−	//! Vim key-notation parser: `<C-x>`, `<S-Tab>`, `gg`, `<Space>w`, mouse buttons and wheel.
	1	+	//! Vim key notation: `n`, `G`, `<C-x>`, `<S-Tab>`, `<Space>w`, `gg`, mouse buttons and wheel.
	2	+	//!
	3	+	//! Keys are normalised so that the config and the keyboard agree: a character already carries
	4	+	//! its shift state (`G`, `?`), so shift is dropped from character keys and `<S-g>` means `G`.
	5	+
	6	+	use std::fmt;
	7	+	use std::str::FromStr;
	8	+
	9	+	#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
	10	+	pub struct Mods {
	11	+	pub ctrl: bool,
	12	+	pub alt: bool,
	13	+	pub shift: bool,
	14	+	/// The logo key, `<D-…>` as in vim.
	15	+	pub sup: bool,
	16	+	}
	17	+
	18	+	impl Mods {
	19	+	pub const NONE: Mods = Mods {
	20	+	ctrl: false,
	21	+	alt: false,
	22	+	shift: false,
	23	+	sup: false,
	24	+	};
	25	+
	26	+	pub fn is_empty(self) -> bool {
	27	+	self == Mods::NONE
	28	+	}
	29	+	}
	30	+
	31	+	#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
	32	+	pub enum Named {
	33	+	Space,
	34	+	Enter,
	35	+	Esc,
	36	+	Tab,
	37	+	Backspace,
	38	+	Delete,
	39	+	Insert,
	40	+	Home,
	41	+	End,
	42	+	PageUp,
	43	+	PageDown,
	44	+	Up,
	45	+	Down,
	46	+	Left,
	47	+	Right,
	48	+	F(u8),
	49	+	}
	50	+
	51	+	#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
	52	+	pub enum Button {
	53	+	Left,
	54	+	Right,
	55	+	Middle,
	56	+	Back,
	57	+	Forward,
	58	+	}
	59	+
	60	+	#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
	61	+	pub enum Scroll {
	62	+	Up,
	63	+	Down,
	64	+	Left,
	65	+	Right,
	66	+	}
	67	+
	68	+	#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
	69	+	pub enum Code {
	70	+	Char(char),
	71	+	Named(Named),
	72	+	Mouse(Button),
	73	+	Scroll(Scroll),
	74	+	}
	75	+
	76	+	/// One key press (or click, or wheel notch) with its modifiers.
	77	+	#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
	78	+	pub struct Key {
	79	+	pub mods: Mods,
	80	+	pub code: Code,
	81	+	}
	82	+
	83	+	impl Key {
	84	+	pub fn new(mods: Mods, code: Code) -> Self {
	85	+	Self { mods, code }.normalized()
	86	+	}
	87	+
	88	+	pub fn plain(c: char) -> Self {
	89	+	Self::new(Mods::NONE, Code::Char(c))
	90	+	}
	91	+
	92	+	/// Characters carry their own shift state; a space is `<Space>`.
	93	+	fn normalized(mut self) -> Self {
	94	+	if let Code::Char(c) = self.code {
	95	+	if c == ' ' {
	96	+	self.code = Code::Named(Named::Space);
	97	+	} else if self.mods.shift {
	98	+	self.code = Code::Char(c.to_uppercase().next().unwrap_or(c));
	99	+	self.mods.shift = false;
	100	+	}
	101	+	}
	102	+	self
	103	+	}
	104	+
	105	+	/// A digit typed without modifiers, which may start or extend a count.
	106	+	pub fn digit(self) -> Option<u32> {
	107	+	match self.code {
	108	+	Code::Char(c) if self.mods.is_empty() => c.to_digit(10),
	109	+	_ => None,
	110	+	}
	111	+	}
	112	+	}
	113	+
	114	+	const NAMES: &[(&str, Code)] = &[
	115	+	("Space", Code::Named(Named::Space)),
	116	+	("CR", Code::Named(Named::Enter)),
	117	+	("Enter", Code::Named(Named::Enter)),
	118	+	("Return", Code::Named(Named::Enter)),
	119	+	("Esc", Code::Named(Named::Esc)),
	120	+	("Escape", Code::Named(Named::Esc)),
	121	+	("Tab", Code::Named(Named::Tab)),
	122	+	("BS", Code::Named(Named::Backspace)),
	123	+	("Backspace", Code::Named(Named::Backspace)),
	124	+	("Del", Code::Named(Named::Delete)),
	125	+	("Delete", Code::Named(Named::Delete)),
	126	+	("Insert", Code::Named(Named::Insert)),
	127	+	("Home", Code::Named(Named::Home)),
	128	+	("End", Code::Named(Named::End)),
	129	+	("PageUp", Code::Named(Named::PageUp)),
	130	+	("PageDown", Code::Named(Named::PageDown)),
	131	+	("Up", Code::Named(Named::Up)),
	132	+	("Down", Code::Named(Named::Down)),
	133	+	("Left", Code::Named(Named::Left)),
	134	+	("Right", Code::Named(Named::Right)),
	135	+	("lt", Code::Char('<')),
	136	+	("gt", Code::Char('>')),
	137	+	("Bar", Code::Char('\|')),
	138	+	("Bslash", Code::Char('\\')),
	139	+	("LeftMouse", Code::Mouse(Button::Left)),
	140	+	("RightMouse", Code::Mouse(Button::Right)),
	141	+	("MiddleMouse", Code::Mouse(Button::Middle)),
	142	+	("X1Mouse", Code::Mouse(Button::Back)),
	143	+	("X2Mouse", Code::Mouse(Button::Forward)),
	144	+	("ScrollUp", Code::Scroll(Scroll::Up)),
	145	+	("ScrollDown", Code::Scroll(Scroll::Down)),
	146	+	("ScrollLeft", Code::Scroll(Scroll::Left)),
	147	+	("ScrollRight", Code::Scroll(Scroll::Right)),
	148	+	("ScrollWheelUp", Code::Scroll(Scroll::Up)),
	149	+	("ScrollWheelDown", Code::Scroll(Scroll::Down)),
	150	+	("ScrollWheelLeft", Code::Scroll(Scroll::Left)),
	151	+	("ScrollWheelRight", Code::Scroll(Scroll::Right)),
	152	+	];
	153	+
	154	+	fn lookup(name: &str) -> Option<Code> {
	155	+	if let Some(n) = name.strip_prefix(['F', 'f'])
	156	+	&& let Ok(n) = n.parse::<u8>()
	157	+	&& (1..=35).contains(&n)
	158	+	{
	159	+	return Some(Code::Named(Named::F(n)));
	160	+	}
	161	+	NAMES
	162	+	.iter()
	163	+	.find(\|(n, _)\| n.eq_ignore_ascii_case(name))
	164	+	.map(\|(_, c)\| *c)
	165	+	}
	166	+
	167	+	fn code_name(code: Code) -> Option<String> {
	168	+	let s = match code {
	169	+	Code::Char('<') => "lt",
	170	+	Code::Char(_) => return None,
	171	+	Code::Named(Named::F(n)) => return Some(format!("F{n}")),
	172	+	Code::Named(Named::Space) => "Space",
	173	+	Code::Named(Named::Enter) => "CR",
	174	+	Code::Named(Named::Esc) => "Esc",
	175	+	Code::Named(Named::Tab) => "Tab",
	176	+	Code::Named(Named::Backspace) => "BS",
	177	+	Code::Named(Named::Delete) => "Del",
	178	+	Code::Named(Named::Insert) => "Insert",
	179	+	Code::Named(Named::Home) => "Home",
	180	+	Code::Named(Named::End) => "End",
	181	+	Code::Named(Named::PageUp) => "PageUp",
	182	+	Code::Named(Named::PageDown) => "PageDown",
	183	+	Code::Named(Named::Up) => "Up",
	184	+	Code::Named(Named::Down) => "Down",
	185	+	Code::Named(Named::Left) => "Left",
	186	+	Code::Named(Named::Right) => "Right",
	187	+	Code::Mouse(Button::Left) => "LeftMouse",
	188	+	Code::Mouse(Button::Right) => "RightMouse",
	189	+	Code::Mouse(Button::Middle) => "MiddleMouse",
	190	+	Code::Mouse(Button::Back) => "X1Mouse",
	191	+	Code::Mouse(Button::Forward) => "X2Mouse",
	192	+	Code::Scroll(Scroll::Up) => "ScrollUp",
	193	+	Code::Scroll(Scroll::Down) => "ScrollDown",
	194	+	Code::Scroll(Scroll::Left) => "ScrollLeft",
	195	+	Code::Scroll(Scroll::Right) => "ScrollRight",
	196	+	};
	197	+	Some(s.into())
	198	+	}
	199	+
	200	+	impl fmt::Display for Key {
	201	+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	202	+	let m = self.mods;
	203	+	let name = code_name(self.code);
	204	+	if m.is_empty()
	205	+	&& let Code::Char(c) = self.code
	206	+	&& name.is_none()
	207	+	{
	208	+	return write!(f, "{c}");
	209	+	}
	210	+	f.write_str("<")?;
	211	+	for (on, p) in [
	212	+	(m.ctrl, "C-"),
	213	+	(m.alt, "A-"),
	214	+	(m.shift, "S-"),
	215	+	(m.sup, "D-"),
	216	+	] {
	217	+	if on {
	218	+	f.write_str(p)?;
	219	+	}
	220	+	}
	221	+	match (name, self.code) {
	222	+	(Some(n), _) => f.write_str(&n)?,
	223	+	(None, Code::Char(c)) => write!(f, "{c}")?,
	224	+	(None, _) => unreachable!("every non-char code has a name"),
	225	+	}
	226	+	f.write_str(">")
	227	+	}
	228	+	}
	229	+
	230	+	/// Parse a `<…>` token at the start of `s`. Returns the key and the bytes consumed, or `None`
	231	+	/// when `s` doesn't start with a well-formed token (a lone `<` is then a literal).
	232	+	fn parse_bracket(s: &str) -> Result<Option<(Key, usize)>, String> {
	233	+	let Some(inner) = s.strip_prefix('<') else {
	234	+	return Ok(None);
	235	+	};
	236	+	let mut mods = Mods::NONE;
	237	+	let mut r = inner;
	238	+	loop {
	239	+	let mut it = r.chars();
	240	+	let (Some(m), Some('-'), Some(_)) = (it.next(), it.next(), it.next()) else {
	241	+	break;
	242	+	};
	243	+	match m.to_ascii_uppercase() {
	244	+	'C' => mods.ctrl = true,
	245	+	'A' \| 'M' => mods.alt = true,
	246	+	'S' => mods.shift = true,
	247	+	'D' \| 'T' => mods.sup = true,
	248	+	_ => break,
	249	+	}
	250	+	r = &r[2..];
	251	+	}
	252	+	let mut it = r.chars();
	253	+	let Some(first) = it.next() else {
	254	+	return Ok(None);
	255	+	};
	256	+	// A single character: `<C-x>`, `<C-->`.
	257	+	if it.next() == Some('>') {
	258	+	if mods.shift && !first.is_alphabetic() {
	259	+	return Err(format!(
	260	+	"`<S-{first}>`: shift only combines with letters and named keys; \
	261	+	write the shifted character instead"
	262	+	));
	263	+	}
	264	+	let used = 1 + (inner.len() - r.len()) + first.len_utf8() + 1;
	265	+	return Ok(Some((Key::new(mods, Code::Char(first)), used)));
	266	+	}
	267	+	let Some(end) = r.find('>') else {
	268	+	return Ok(None);
	269	+	};
	270	+	let name = &r[..end];
	271	+	if !name.chars().all(\|c\| c.is_ascii_alphanumeric()) {
	272	+	return Ok(None);
	273	+	}
	274	+	let used = 1 + (inner.len() - r.len()) + end + 1;
	275	+	match lookup(name) {
	276	+	Some(code) => {
	277	+	if mods.shift && matches!(code, Code::Char(c) if !c.is_alphabetic()) {
	278	+	return Err(format!(
	279	+	"`<S-{name}>`: shift only combines with letters and named keys"
	280	+	));
	281	+	}
	282	+	Ok(Some((Key::new(mods, code), used)))
	283	+	}
	284	+	None if mods.is_empty() && !inner.starts_with(char::is_alphabetic) => Ok(None),
	285	+	None => Err(format!("unknown key `<{}>`", &inner[..used - 2])),
	286	+	}
	287	+	}
	288	+
	289	+	/// A key sequence such as `gg` or `<Space>w`.
	290	+	#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
	291	+	pub struct KeySeq(pub Vec<Key>);
	292	+
	293	+	impl FromStr for KeySeq {
	294	+	type Err = String;
	295	+
	296	+	fn from_str(s: &str) -> Result<Self, String> {
	297	+	let mut keys = Vec::new();
	298	+	let mut rest = s;
	299	+	while let Some(c) = rest.chars().next() {
	300	+	if c == '<'
	301	+	&& let Some((key, used)) = parse_bracket(rest)?
	302	+	{
	303	+	keys.push(key);
	304	+	rest = &rest[used..];
	305	+	continue;
	306	+	}
	307	+	if c.is_control() {
	308	+	return Err(format!("control character in key `{}`", s.escape_debug()));
	309	+	}
	310	+	keys.push(Key::plain(c));
	311	+	rest = &rest[c.len_utf8()..];
	312	+	}
	313	+	if keys.is_empty() {
	314	+	return Err("empty key".into());
	315	+	}
	316	+	Ok(KeySeq(keys))
	317	+	}
	318	+	}
	319	+
	320	+	impl fmt::Display for KeySeq {
	321	+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	322	+	self.0.iter().try_for_each(\|k\| write!(f, "{k}"))
	323	+	}
	324	+	}
	325	+
	326	+	#[cfg(test)]
	327	+	mod tests {
	328	+	use super::*;
	329	+
	330	+	fn seq(s: &str) -> Vec<Key> {
	331	+	s.parse::<KeySeq>().unwrap().0
	332	+	}
	333	+
	334	+	fn ctrl() -> Mods {
	335	+	Mods {
	336	+	ctrl: true,
	337	+	..Mods::NONE
	338	+	}
	339	+	}
	340	+
	341	+	#[test]
	342	+	fn plain_characters_and_sequences() {
	343	+	assert_eq!(seq("n"), [Key::plain('n')]);
	344	+	assert_eq!(seq("gg"), [Key::plain('g'), Key::plain('g')]);
	345	+	assert_eq!(seq("G"), [Key::plain('G')]);
	346	+	assert_eq!(seq("<"), [Key::plain('<')]);
	347	+	assert_eq!(seq("<>"), [Key::plain('<'), Key::plain('>')]);
	348	+	assert_eq!(seq("\|"), [Key::plain('\|')]);
	349	+	assert_eq!(seq(" "), [Key::new(Mods::NONE, Code::Named(Named::Space))]);
	350	+	}
	351	+
	352	+	#[test]
	353	+	fn bracket_notation() {
	354	+	assert_eq!(seq("<C-x>"), [Key::new(ctrl(), Code::Char('x'))]);
	355	+	assert_eq!(seq("<c-X>"), [Key::new(ctrl(), Code::Char('X'))]);
	356	+	assert_eq!(seq("<C-->"), [Key::new(ctrl(), Code::Char('-'))]);
	357	+	let shift = Mods {
	358	+	shift: true,
	359	+	..Mods::NONE
	360	+	};
	361	+	assert_eq!(seq("<S-Tab>"), [Key::new(shift, Code::Named(Named::Tab))]);
	362	+	assert_eq!(seq("<S-g>"), [Key::plain('G')]);
	363	+	assert_eq!(seq("<cr>"), seq("<Enter>"));
	364	+	assert_eq!(seq("<lt>"), [Key::plain('<')]);
	365	+	assert_eq!(
	366	+	seq("<F5>"),
	367	+	[Key::new(Mods::NONE, Code::Named(Named::F(5)))]
	368	+	);
	369	+	assert_eq!(
	370	+	seq("<Space>w"),
	371	+	[
	372	+	Key::new(Mods::NONE, Code::Named(Named::Space)),
	373	+	Key::plain('w')
	374	+	]
	375	+	);
	376	+	assert_eq!(
	377	+	seq("<C-ScrollUp>"),
	378	+	[Key::new(ctrl(), Code::Scroll(Scroll::Up))]
	379	+	);
	380	+	assert_eq!(
	381	+	seq("<LeftMouse>"),
	382	+	[Key::new(Mods::NONE, Code::Mouse(Button::Left))]
	383	+	);
	384	+	assert_eq!(
	385	+	seq("<C-S-A-Up>"),
	386	+	[Key::new(
	387	+	Mods {
	388	+	ctrl: true,
	389	+	alt: true,
	390	+	shift: true,
	391	+	sup: false
	392	+	},
	393	+	Code::Named(Named::Up)
	394	+	)]
	395	+	);
	396	+	}
	397	+
	398	+	#[test]
	399	+	fn errors() {
	400	+	assert!("".parse::<KeySeq>().is_err());
	401	+	assert!("<C-Bogus>".parse::<KeySeq>().is_err());
	402	+	assert!("<Bogus>".parse::<KeySeq>().is_err());
	403	+	assert!("<S-1>".parse::<KeySeq>().is_err());
	404	+	}
	405	+
	406	+	#[test]
	407	+	fn display_round_trips() {
	408	+	for s in [
	409	+	"n",
	410	+	"gg",
	411	+	"<C-x>",
	412	+	"<S-Tab>",
	413	+	"<Space>w",
	414	+	"<lt>",
	415	+	"<C-Space>",
	416	+	"<C-ScrollUp>",
	417	+	"<F12>",
	418	+	"<CR>",
	419	+	"\|",
	420	+	"<C-->",
	421	+	"<A-D-x>",
	422	+	] {
	423	+	let k: KeySeq = s.parse().unwrap();
	424	+	assert_eq!(k.to_string(), s);
	425	+	assert_eq!(k.to_string().parse::<KeySeq>().unwrap(), k);
	426	+	}
	427	+	assert_eq!("<S-a>".parse::<KeySeq>().unwrap().to_string(), "A");
	428	+	assert_eq!("<escape>".parse::<KeySeq>().unwrap().to_string(), "<Esc>");
	429	+	}
	430	+
	431	+	#[test]
	432	+	fn digits() {
	433	+	assert_eq!(Key::plain('5').digit(), Some(5));
	434	+	assert_eq!(Key::new(ctrl(), Code::Char('5')).digit(), None);
	435	+	assert_eq!(Key::plain('x').digit(), None);
	436	+	}
	437	+	}

		@@ -1,173 +1,120 @@
1		−	//! Keyboard and mouse input: vim key notation and per-mode keymaps.
2		−	//!
3		−	//! Until the configurable keymap lands (M2), [`Input`] holds the default bindings in code.
	1	+	//! Keyboard and mouse input: vim key notation, per-mode keymaps, and the bridge from winit.
4	2
5	3		pub mod keymap;
6	4		pub mod keys;
7	5
8		−	use winit::keyboard::{Key, ModifiersState, NamedKey};
	6	+	use winit::event::MouseButton;
	7	+	use winit::keyboard::{Key as WinitKey, ModifiersState, NamedKey};
9	8
10		−	use crate::action::{Action, Zoom};
11		−	use crate::state::view::{Axis, Dir, FitMode};
	9	+	use keys::{Button, Code, Key, Mods, Named, Scroll};
12	10
13		−	#[derive(Debug, Default)]
14		−	pub struct Input {
15		−	/// A `g` is waiting for its second key.
16		−	pending_g: bool,
17		−	/// A count prefix (`5n`, `12G`).
18		−	count: Option<usize>,
	11	+	pub fn mods(m: ModifiersState) -> Mods {
	12	+	Mods {
	13	+	ctrl: m.control_key(),
	14	+	alt: m.alt_key(),
	15	+	shift: m.shift_key(),
	16	+	sup: m.super_key(),
	17	+	}
19	18		}
20	19
21		−	impl Input {
22		−	/// The incomplete sequence typed so far, for the status bar.
23		−	pub fn pending(&self) -> String {
24		−	let mut s = self.count.map(\|c\| c.to_string()).unwrap_or_default();
25		−	if self.pending_g {
26		−	s.push('g');
	20	+	/// A key press in vim terms. Modifier keys on their own, dead keys and unnamed keys give `None`.
	21	+	pub fn key(key: &WinitKey, m: ModifiersState) -> Option<Key> {
	22	+	let code = match key {
	23	+	WinitKey::Character(s) => {
	24	+	let mut chars = s.chars();
	25	+	match (chars.next(), chars.next()) {
	26	+	(Some(c), None) => Code::Char(c),
	27	+	_ => return None,
	28	+	}
27	29		}
28		−	s
29		−	}
	30	+	WinitKey::Named(n) => Code::Named(match n {
	31	+	NamedKey::Space => Named::Space,
	32	+	NamedKey::Enter => Named::Enter,
	33	+	NamedKey::Escape => Named::Esc,
	34	+	NamedKey::Tab => Named::Tab,
	35	+	NamedKey::Backspace => Named::Backspace,
	36	+	NamedKey::Delete => Named::Delete,
	37	+	NamedKey::Insert => Named::Insert,
	38	+	NamedKey::Home => Named::Home,
	39	+	NamedKey::End => Named::End,
	40	+	NamedKey::PageUp => Named::PageUp,
	41	+	NamedKey::PageDown => Named::PageDown,
	42	+	NamedKey::ArrowUp => Named::Up,
	43	+	NamedKey::ArrowDown => Named::Down,
	44	+	NamedKey::ArrowLeft => Named::Left,
	45	+	NamedKey::ArrowRight => Named::Right,
	46	+	other => {
	47	+	return function_key(*other)
	48	+	.map(Named::F)
	49	+	.map(\|f\| Key::new(mods(m), Code::Named(f)));
	50	+	}
	51	+	}),
	52	+	_ => return None,
	53	+	};
	54	+	Some(Key::new(mods(m), code))
	55	+	}
30	56
31		−	pub fn cancel(&mut self) {
32		−	self.pending_g = false;
33		−	self.count = None;
34		−	}
	57	+	fn function_key(n: NamedKey) -> Option<u8> {
	58	+	use NamedKey::*;
	59	+	const F: [NamedKey; 35] = [
	60	+	F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20,
	61	+	F21, F22, F23, F24, F25, F26, F27, F28, F29, F30, F31, F32, F33, F34, F35,
	62	+	];
	63	+	F.iter().position(\|f\| *f == n).map(\|i\| i as u8 + 1)
	64	+	}
35	65
36		−	/// Map a key press to an action using the default bindings.
37		−	pub fn key(&mut self, key: &Key, mods: ModifiersState) -> Option<Action> {
38		−	if mods.control_key() \|\| mods.alt_key() \|\| mods.super_key() {
39		−	return None;
40		−	}
41		−	if let Key::Character(s) = key {
42		−	// `0` is a motion unless a count is already pending.
43		−	if let Some(d) = s.chars().next().and_then(\|c\| c.to_digit(10))
44		−	&& s.len() == 1
45		−	&& !self.pending_g
46		−	&& (d != 0 \|\| self.count.is_some())
47		−	{
48		−	self.count = Some(
49		−	self.count
50		−	.unwrap_or(0)
51		−	.saturating_mul(10)
52		−	.saturating_add(d as usize)
53		−	.min(9_999_999),
54		−	);
55		−	return None;
56		−	}
57		−	}
58		−	let was_g = std::mem::take(&mut self.pending_g);
59		−	if !was_g && matches!(key, Key::Character(s) if s == "g") {
60		−	self.pending_g = true;
61		−	return None;
62		−	}
63		−	let count = self.count.take();
64		−	let n = count.unwrap_or(1);
65		−	let action = match key {
66		−	Key::Character(s) => match s.as_str() {
67		−	"g" => count.map_or(Action::First, Action::Goto),
68		−	"q" => Action::Quit,
69		−	"n" => Action::Next(n),
70		−	"p" => Action::Prev(n),
71		−	"]" => Action::Next(10 * n),
72		−	"[" => Action::Prev(10 * n),
73		−	"G" => count.map_or(Action::Last, Action::Goto),
74		−	"h" => Action::Pan(Dir::Left),
75		−	"j" => Action::Pan(Dir::Down),
76		−	"k" => Action::Pan(Dir::Up),
77		−	"l" => Action::Pan(Dir::Right),
78		−	"H" => Action::PanEdge(Dir::Left),
79		−	"J" => Action::PanEdge(Dir::Down),
80		−	"K" => Action::PanEdge(Dir::Up),
81		−	"L" => Action::PanEdge(Dir::Right),
82		−	"+" => Action::Zoom(Zoom::In),
83		−	"-" => Action::Zoom(Zoom::Out),
84		−	"=" => Action::Zoom(Zoom::Percent(100.0)),
85		−	"w" => Action::Fit(FitMode::Fit),
86		−	"W" => Action::Fit(FitMode::Fill),
87		−	"e" => Action::Fit(FitMode::Width),
88		−	"E" => Action::Fit(FitMode::Height),
89		−	"z" => Action::Center,
90		−	"<" => Action::Rotate(-1),
91		−	">" => Action::Rotate(1),
92		−	"\|" => Action::Flip(Axis::Horizontal),
93		−	"_" => Action::Flip(Axis::Vertical),
94		−	"a" => Action::FilterToggle,
95		−	"A" => Action::AlphaBgCycle,
96		−	"f" => Action::Fullscreen,
97		−	"b" => Action::BarToggle,
98		−	"r" => Action::Reload,
99		−	"D" => Action::Remove,
100		−	_ => return None,
101		−	},
102		−	Key::Named(named) => match named {
103		−	NamedKey::Backspace => Action::Prev(n),
104		−	NamedKey::Escape => Action::Cancel,
105		−	NamedKey::ArrowLeft => Action::Pan(Dir::Left),
106		−	NamedKey::ArrowDown => Action::Pan(Dir::Down),
107		−	NamedKey::ArrowUp => Action::Pan(Dir::Up),
108		−	NamedKey::ArrowRight => Action::Pan(Dir::Right),
109		−	NamedKey::Home => Action::First,
110		−	NamedKey::End => Action::Last,
111		−	_ => return None,
112		−	},
113		−	_ => return None,
114		−	};
115		−	Some(action)
116		−	}
	66	+	pub fn button(b: MouseButton, m: ModifiersState) -> Option<Key> {
	67	+	let b = match b {
	68	+	MouseButton::Left => Button::Left,
	69	+	MouseButton::Right => Button::Right,
	70	+	MouseButton::Middle => Button::Middle,
	71	+	MouseButton::Back => Button::Back,
	72	+	MouseButton::Forward => Button::Forward,
	73	+	MouseButton::Other(_) => return None,
	74	+	};
	75	+	Some(Key::new(mods(m), Code::Mouse(b)))
117	76		}
118	77
119		−	/// Whether holding the key should repeat the action.
120		−	pub fn repeats(action: &Action) -> bool {
121		−	matches!(
122		−	action,
123		−	Action::Next(_) \| Action::Prev(_) \| Action::Zoom(Zoom::In \| Zoom::Out)
124		−	)
	78	+	pub fn scroll(dir: Scroll, m: ModifiersState) -> Key {
	79	+	Key::new(mods(m), Code::Scroll(dir))
125	80		}
126	81
127	82		#[cfg(test)]
128	83		mod tests {
129	84		use super::*;
	85	+	use keys::KeySeq;
130	86
131		−	fn ch(s: &str) -> Key {
132		−	Key::Character(s.into())
	87	+	fn k(s: &str) -> Key {
	88	+	s.parse::<KeySeq>().unwrap().0[0]
133	89		}
134	90
135	91		#[test]
136		−	fn gg_is_a_sequence() {
137		−	let mut input = Input::default();
	92	+	fn winit_keys_match_notation() {
138	93		let none = ModifiersState::empty();
139		−	assert_eq!(input.key(&ch("g"), none), None);
140		−	assert_eq!(input.pending(), "g");
141		−	assert_eq!(input.key(&ch("g"), none), Some(Action::First));
142		−	assert_eq!(input.key(&ch("g"), none), None);
143		−	assert_eq!(input.key(&ch("n"), none), Some(Action::Next(1)));
144		−	assert_eq!(input.pending(), "");
145		−	}
146		−
147		−	#[test]
148		−	fn counts() {
149		−	let mut input = Input::default();
150		−	let none = ModifiersState::empty();
151		−	for k in ["1", "2"] {
152		−	assert_eq!(input.key(&ch(k), none), None);
153		−	}
154		−	assert_eq!(input.pending(), "12");
155		−	assert_eq!(input.key(&ch("G"), none), Some(Action::Goto(12)));
156		−	assert_eq!(input.key(&ch("3"), none), None);
157		−	assert_eq!(input.key(&ch("n"), none), Some(Action::Next(3)));
158		−	assert_eq!(input.key(&ch("G"), none), Some(Action::Last));
159		−	// `0` alone is not a count.
160		−	assert_eq!(input.key(&ch("0"), none), None);
161		−	assert_eq!(input.pending(), "");
162		−	input.key(&ch("5"), none);
163		−	input.key(&ch("g"), none);
164		−	assert_eq!(input.pending(), "5g");
165		−	assert_eq!(input.key(&ch("g"), none), Some(Action::Goto(5)));
166		−	}
167		−
168		−	#[test]
169		−	fn modifiers_block_plain_bindings() {
170		−	let mut input = Input::default();
171		−	assert_eq!(input.key(&ch("n"), ModifiersState::CONTROL), None);
	94	+	let ch = \|s: &str\| WinitKey::Character(s.into());
	95	+	assert_eq!(key(&ch("n"), none), Some(k("n")));
	96	+	// Shift is already in the character.
	97	+	assert_eq!(key(&ch("G"), ModifiersState::SHIFT), Some(k("G")));
	98	+	assert_eq!(key(&ch("?"), ModifiersState::SHIFT), Some(k("?")));
	99	+	assert_eq!(key(&ch("x"), ModifiersState::CONTROL), Some(k("<C-x>")));
	100	+	assert_eq!(key(&ch(" "), none), Some(k("<Space>")));
	101	+	assert_eq!(
	102	+	key(&WinitKey::Named(NamedKey::Space), ModifiersState::CONTROL),
	103	+	Some(k("<C-Space>"))
	104	+	);
	105	+	assert_eq!(
	106	+	key(&WinitKey::Named(NamedKey::Tab), ModifiersState::SHIFT),
	107	+	Some(k("<S-Tab>"))
	108	+	);
	109	+	assert_eq!(key(&WinitKey::Named(NamedKey::F5), none), Some(k("<F5>")));
	110	+	assert_eq!(
	111	+	key(&WinitKey::Named(NamedKey::Shift), ModifiersState::SHIFT),
	112	+	None
	113	+	);
	114	+	assert_eq!(button(MouseButton::Right, none), Some(k("<RightMouse>")));
	115	+	assert_eq!(
	116	+	scroll(Scroll::Up, ModifiersState::CONTROL),
	117	+	k("<C-ScrollUp>")
	118	+	);
172	119		}
173	120		}

		@@ -17,12 +17,13 @@ mod thumbs;
17	17		mod ui;
18	18		mod worker;
19	19
	20	+	use std::path::Path;
20	21		use std::time::Instant;
21	22
22	23		use clap::Parser;
23	24		use winit::event_loop::EventLoop;
24	25
25		−	use app::{App, Options, UserEvent};
	26	+	use app::{App, Options, Overrides, UserEvent};
26	27		use state::queue::Queue;
27	28		use state::{AppState, MsgKind, Settings};
28	29
		@@ -30,15 +31,37 @@ fn main() -> anyhow::Result<()> {
30	31		let started = Instant::now();
31	32		env_logger::init();
32	33		let cli = cli::Cli::parse();
	34	+	if cli.dump_config {
	35	+	print!("{}", config::dump());
	36	+	return Ok(());
	37	+	}
	38	+	if cli.check_config {
	39	+	check_config(cli.config.as_deref());
	40	+	}
33	41		log::info!("remage {}", env!("CARGO_PKG_VERSION"));
34	42
	43	+	let (loaded, config_error) = match config::load(cli.config.as_deref()) {
	44	+	Ok(l) => (l, None),
	45	+	Err(e) => {
	46	+	log::error!("{e}");
	47	+	let mut d = config::defaults();
	48	+	d.watch = e.watch;
	49	+	(d, Some(e.message))
	50	+	}
	51	+	};
	52	+	for w in &loaded.warnings {
	53	+	log::warn!("{w}");
	54	+	}
	55	+	log::debug!("config loaded after {:.1?}", started.elapsed());
	56	+	let cfg = &loaded.config;
	57	+
35	58		let scan = scan::scan(
36	59		&cli.paths,
37	60		&scan::ScanOptions {
38		−	recursive: cli.recursive,
39		−	siblings: !cli.no_siblings,
40		−	sort: cli.sort,
41		−	reverse: cli.reverse,
	61	+	recursive: cli.recursive \|\| cfg.general.recursive,
	62	+	siblings: !cli.no_siblings && cfg.general.open_siblings,
	63	+	sort: cli.sort.unwrap_or(cfg.general.sort),
	64	+	reverse: cli.reverse \|\| cfg.general.reverse,
42	65		},
43	66		);
44	67		log::debug!(
		@@ -48,14 +71,20 @@ fn main() -> anyhow::Result<()> {
48	71		started.elapsed()
49	72		);
50	73
51		−	let settings = Settings {
52		−	fit: cli.fit.unwrap_or(Settings::default().fit),
	74	+	let overrides = Overrides {
	75	+	fit: cli.fit,
53	76		zoom: cli.zoom.map(\|z\| z / 100.0),
54		−	..Settings::default()
	77	+	bar: cli.no_bar.then_some(false),
55	78		};
	79	+	let mut settings = Settings::from_config(cfg);
	80	+	overrides.apply(&mut settings);
56	81		let start_index = cli.start.unwrap_or(1).saturating_sub(1);
57	82		let queue = Queue::new(scan.files, scan.start.as_deref(), start_index);
58		−	let mut state = AppState::new(queue, settings, !cli.no_bar, Instant::now());
	83	+	let bar = overrides.bar.unwrap_or(cfg.ui.statusbar);
	84	+	let mut state = AppState::new(queue, settings, bar, Instant::now());
	85	+	state.theme = loaded.theme.clone();
	86	+	state.nearest = cfg.image.filter.nearest();
	87	+	state.alpha_bg = cfg.image.alpha_background;
59	88		if let Some(err) = scan.errors.first() {
60	89		state.notify(format!("error: {err}"), MsgKind::Error, Instant::now());
61	90		}
		@@ -72,17 +101,47 @@ fn main() -> anyhow::Result<()> {
72	101		}
73	102		});
74	103		}
	104	+	let watch = {
	105	+	let proxy = proxy.clone();
	106	+	config::watch::spawn(cli.config.clone(), loaded.watch.clone(), move \|r\| {
	107	+	let _ = proxy.send_event(UserEvent::Config(Box::new(r)));
	108	+	})
	109	+	};
75	110
76	111		let opts = Options {
77		−	fullscreen: cli.fullscreen,
	112	+	fullscreen: cli.fullscreen \|\| cfg.window.fullscreen,
78	113		geometry: cli.geometry,
79		−	class: cli.class,
80		−	cache_mb: 512,
	114	+	class: cli.class.unwrap_or_else(\|\| cfg.window.class.clone()),
	115	+	overrides,
81	116		};
82		−	let mut app = App::new(opts, state, proxy);
	117	+	let mut app = App::new(opts, state, proxy, loaded, watch);
	118	+	if let Some(e) = config_error {
	119	+	app.config_failed(&e);
	120	+	}
83	121		event_loop.run_app(&mut app)?;
84	122		match app.error.take() {
85	123		Some(e) => Err(e),
86	124		None => Ok(()),
87	125		}
88	126		}
	127	+
	128	+	/// `--check-config`: report and exit, non-zero on errors.
	129	+	fn check_config(path: Option<&Path>) -> ! {
	130	+	match config::load(path) {
	131	+	Ok(l) => {
	132	+	for w in &l.warnings {
	133	+	eprintln!("warning: {w}");
	134	+	}
	135	+	match path.map(Path::to_path_buf).or_else(config::default_path) {
	136	+	Some(p) if p.is_file() => println!("{}: ok", p.display()),
	137	+	Some(p) => println!("{} not found: using the defaults", p.display()),
	138	+	None => println!("no config directory: using the defaults"),
	139	+	}
	140	+	std::process::exit(0)
	141	+	}
	142	+	Err(e) => {
	143	+	eprintln!("{e}");
	144	+	std::process::exit(1)
	145	+	}
	146	+	}
	147	+	}

		@@ -153,6 +153,10 @@ impl Renderer {
153	153		self.text.measure(item)
154	154		}
155	155
	156	+	pub fn set_font_families(&mut self, families: [String; 3]) {
	157	+	self.text.set_families(families);
	158	+	}
	159	+
156	160		pub fn set_fonts(&mut self, db: glyphon::fontdb::Database) {
157	161		self.text.set_fonts(&self.device, &self.queue, db);
158	162		}

		@@ -31,15 +31,18 @@ pub enum FontRole {
31	31		}
32	32
33	33		impl FontRole {
34		−	fn family(self) -> &'static str {
	34	+	fn index(self) -> usize {
35	35		match self {
36		−	FontRole::Ui => "Space Grotesk",
37		−	FontRole::Mono => "Space Mono",
38		−	FontRole::Display => "Doto",
	36	+	FontRole::Ui => 0,
	37	+	FontRole::Mono => 1,
	38	+	FontRole::Display => 2,
39	39		}
40	40		}
41	41		}
42	42
	43	+	/// The embedded families: UI, mono, display.
	44	+	pub const DEFAULT_FAMILIES: [&str; 3] = ["Space Grotesk", "Space Mono", "Doto"];
	45	+
43	46		#[derive(Clone, Copy, Debug, PartialEq, Eq)]
44	47		pub enum Align {
45	48		Left,
		@@ -102,6 +105,8 @@ pub struct TextSystem {
102	105		viewport: Viewport,
103	106		format: wgpu::TextureFormat,
104	107		shaped: HashMap<Key, Shaped>,
	108	+	/// Family names per [`FontRole`], from `ui.font_*`.
	109	+	families: [String; 3],
105	110		}
106	111
107	112		/// Locale for shaping, from the usual environment variables.
		@@ -149,6 +154,14 @@ impl TextSystem {
149	154		viewport,
150	155		format,
151	156		shaped: HashMap::new(),
	157	+	families: DEFAULT_FAMILIES.map(String::from),
	158	+	}
	159	+	}
	160	+
	161	+	pub fn set_families(&mut self, families: [String; 3]) {
	162	+	if families != self.families {
	163	+	self.families = families;
	164	+	self.shaped.clear();
152	165		}
153	166		}
154	167
		@@ -175,8 +188,9 @@ impl TextSystem {
175	188		let line_height = (item.size * 1.25).ceil();
176	189		let mut buffer = Buffer::new(&mut self.fonts, Metrics::new(item.size, line_height));
177	190		buffer.set_size(None, None);
	191	+	let family = self.families[item.role.index()].clone();
178	192		let base = Attrs::new()
179		−	.family(Family::Name(item.role.family()))
	193	+	.family(Family::Name(&family))
180	194		.weight(Weight(item.weight))
181	195		.letter_spacing(item.tracking);
182	196		let spans = item.spans.iter().map(\|(s, c)\| {

		@@ -1,17 +1,53 @@
1		−	//! Every user-facing operation. Keys produce these today; the palette, IPC and command
2		−	//! output will share the same grammar (parser and `Display` arrive with the keymap in M2).
	1	+	//! Every user-facing operation, with one grammar (`name [args]`) shared by key bindings, the
	2	+	//! palette, IPC and command output. `parse(display(a)) == a` for every action.
3	3
	4	+	use std::fmt;
	5	+	use std::str::FromStr;
	6	+
	7	+	use clap::ValueEnum;
	8	+
	9	+	use crate::config::suggest;
	10	+	use crate::state::queue::SortKey;
4	11		use crate::state::view::{Axis, Dir, FitMode};
5	12
6	13		#[derive(Clone, Copy, Debug, PartialEq)]
7	14		pub enum Zoom {
8		−	In,
9		−	Out,
	15	+	/// Zoom steps.
	16	+	In(u32),
	17	+	Out(u32),
10	18		/// Absolute zoom, 100 = one image pixel per screen pixel.
11	19		Percent(f32),
12	20		}
13	21
14		−	#[derive(Clone, Copy, Debug, PartialEq)]
	22	+	#[derive(Clone, Copy, Debug, PartialEq, Eq)]
	23	+	pub enum Switch {
	24	+	Toggle,
	25	+	On,
	26	+	Off,
	27	+	}
	28	+
	29	+	#[derive(Clone, Copy, Debug, PartialEq, Eq)]
	30	+	pub enum ModeArg {
	31	+	Image,
	32	+	Grid,
	33	+	Toggle,
	34	+	}

		@@ -58,6 +58,11 @@ pub fn scan(args: &[PathBuf], opts: &ScanOptions) -> Scan {
58	58		}
59	59
60	60		fn sort(files: &mut [PathBuf], opts: &ScanOptions) {
	61	+	sort_paths(files, opts.sort, opts.reverse);
	62	+	}
	63	+
	64	+	/// Sort with the filesystem metadata the stat-based keys need. Can be slow: not on the UI thread.
	65	+	pub fn sort_paths(files: &mut [PathBuf], key: SortKey, reverse: bool) {
61	66		let meta = \|p: &Path\| {
62	67		std::fs::metadata(p).map_or((0, 0), \|m\| {
63	68		let mtime = m
		@@ -71,7 +76,7 @@ fn sort(files: &mut [PathBuf], opts: &ScanOptions) {
71	76		let seed = SystemTime::now()
72	77		.duration_since(UNIX_EPOCH)
73	78		.map_or(1, \|d\| d.as_nanos() as u64);
74		−	sort_files(files, opts.sort, opts.reverse, meta, seed);
	79	+	sort_files(files, key, reverse, meta, seed);
75	80		}
76	81
77	82		/// Collect visible files under `dir`. Symlinked directories are not followed.

		@@ -7,9 +7,11 @@ pub mod view;
7	7		use std::path::{Path, PathBuf};
8	8		use std::time::{Duration, Instant};
9	9
10		−	use crate::action::{Action, Zoom};
	10	+	use crate::action::{Action, ModeArg, Switch, Zoom};
11	11		use crate::anim::Tween;
12		−	use queue::Queue;
	12	+	use crate::config::theme::Theme;
	13	+	use crate::config::{Config, Transition};
	14	+	use queue::{Queue, SortKey};
13	15		use view::{Affine, Dir, FitMode, View};
14	16
15	17		/// `[LOADING]` appears only once a load has taken this long, so it never flickers.
		@@ -20,8 +22,22 @@ const MIN_PAN_HOLD: Duration = Duration::from_millis(120);
20	22		const PAN_SPEED: f32 = 1.25;
21	23		/// Logical height of the status bar.
22	24		pub const BAR_HEIGHT: f32 = 32.0;
	25	+	/// Image switch crossfade with `transition = "fade"`.
	26	+	const CROSSFADE: Duration = Duration::from_millis(100);
	27	+	/// Theme changes (a new wallpaper palette) crossfade this long.
	28	+	const THEME_FADE: Duration = Duration::from_millis(250);
	29	+
	30	+	/// Which keymap applies, and (from M3) what is on screen.
	31	+	#[allow(dead_code)] // grid and visual arrive in M3
	32	+	#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
	33	+	pub enum Mode {
	34	+	#[default]
	35	+	Image,
	36	+	Grid,
	37	+	Visual,
	38	+	}
23	39
24		−	#[derive(Clone, Debug)]
	40	+	#[derive(Clone, Debug, PartialEq)]
25	41		pub struct Settings {
26	42		pub fit: FitMode,
27	43		pub zoom: Option<f32>,
		@@ -30,6 +46,10 @@ pub struct Settings {
30	46		pub preload: usize,
31	47		pub anim: Duration,
32	48		pub crossfade: Duration,
	49	+	pub theme_fade: Duration,
	50	+	/// UI size multiplier on top of the display scale.
	51	+	pub ui_scale: f32,
	52	+	pub which_key_delay: Duration,
33	53		}
34	54
35	55		impl Default for Settings {
		@@ -41,13 +61,40 @@ impl Default for Settings {
41	61		wrap: true,
42	62		preload: 2,
43	63		anim: Duration::from_millis(180),
44		−	crossfade: Duration::from_millis(100),
	64	+	crossfade: CROSSFADE,
	65	+	theme_fade: THEME_FADE,
	66	+	ui_scale: 1.0,
	67	+	which_key_delay: Duration::from_millis(300),
45	68		}
46	69		}
47	70		}
48	71
49		−	#[derive(Clone, Copy, Debug, PartialEq, Eq)]
	72	+	impl Settings {
	73	+	pub fn from_config(c: &Config) -> Self {
	74	+	let on = c.animation.enabled;
	75	+	let anim = \|d: Duration\| if on { d } else { Duration::ZERO };
	76	+	Self {
	77	+	fit: c.image.fit,
	78	+	zoom: None,
	79	+	zoom_step: c.image.zoom_step,
	80	+	wrap: c.general.wrap,
	81	+	preload: c.image.preload,
	82	+	anim: anim(Duration::from_millis(c.animation.duration_ms)),
	83	+	crossfade: match c.animation.transition {
	84	+	Transition::Fade => anim(CROSSFADE),
	85	+	Transition::None => Duration::ZERO,
	86	+	},
	87	+	theme_fade: anim(THEME_FADE),
	88	+	ui_scale: c.ui.scale,
	89	+	which_key_delay: Duration::from_millis(c.ui.which_key_delay_ms),
	90	+	}
	91	+	}
	92	+	}
	93	+
	94	+	#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
	95	+	#[serde(rename_all = "lowercase")]
50	96		pub enum AlphaBg {
	97	+	#[default]
51	98		Dots,
52	99		Checker,
53	100		Solid,
		@@ -106,10 +153,15 @@ pub struct Effects {
106	153		pub redraw: bool,
107	154		/// The queue's current file changed: load it and refresh the preload window.
108	155		pub navigated: bool,
	156	+	/// The queue order changed around the current file: refresh the preload window.
	157	+	pub reordered: bool,
109	158		/// The status bar appeared or vanished, so the image area changed.
110	159		pub layout: bool,
111		−	pub fullscreen: bool,
	160	+	pub fullscreen: Option<Switch>,
112	161		pub reload: bool,
	162	+	pub reload_config: bool,
	163	+	/// Re-sort the queue (stat-based keys need the filesystem, so the loop does it).
	164	+	pub sort: Option<SortKey>,
113	165		pub quit: bool,
114	166		}
115	167
		@@ -118,6 +170,10 @@ pub struct AppState {
118	170		pub queue: Queue,
119	171		pub view: View,
120	172		pub settings: Settings,
	173	+	pub mode: Mode,
	174	+	pub theme: Theme,
	175	+	/// The previous theme fading out after a reload.
	176	+	theme_fade: Option<(Theme, Tween<f32>)>,
121	177		pub bar: bool,
122	178		/// `None` = automatic (nearest above 300%), otherwise forced nearest/linear.
123	179		pub nearest: Option<bool>,
		@@ -141,6 +197,9 @@ impl AppState {
141	197		queue,
142	198		view: View::new(now),
143	199		settings,
	200	+	mode: Mode::Image,
	201	+	theme: Theme::nothing_dark(),
	202	+	theme_fade: None,
144	203		bar,
145	204		nearest: None,
146	205		alpha_bg: AlphaBg::Dots,
		@@ -172,10 +231,15 @@ impl AppState {
172	231		self.scale_factor
173	232		}
174	233
	234	+	/// Display scale times `ui.scale`: the factor for every UI size.
	235	+	pub fn ui_scale(&self) -> f32 {
	236	+	self.scale_factor * self.settings.ui_scale
	237	+	}
	238	+
175	239		/// Physical height of the status bar, 0 when hidden.
176	240		pub fn bar_height(&self) -> f32 {
177	241		if self.bar {
178		−	(BAR_HEIGHT * self.scale_factor).round()
	242	+	(BAR_HEIGHT * self.ui_scale()).round()
179	243		} else {
180	244		0.0
181	245		}
		@@ -190,25 +254,77 @@ impl AppState {
190	254		self.settings.anim
191	255		}
192	256
	257	+	/// Apply settings from a (re)loaded config. The view keeps its zoom until the next image.
	258	+	pub fn set_settings(&mut self, settings: Settings) {
	259	+	self.settings = settings;
	260	+	self.update_viewport();
	261	+	}
	262	+
	263	+	/// Switch to a new theme, crossfading from whatever is on screen now.
	264	+	pub fn set_theme(&mut self, theme: Theme, now: Instant) {
	265	+	if theme == self.theme {
	266	+	return;
	267	+	}
	268	+	let shown = self.theme_at(now);
	269	+	self.theme = theme;
	270	+	if self.settings.theme_fade.is_zero() {
	271	+	self.theme_fade = None;
	272	+	return;
	273	+	}
	274	+	let mut t = Tween::new(0.0, now);
	275	+	t.retarget(1.0, now, self.settings.theme_fade);
	276	+	self.theme_fade = Some((shown, t));
	277	+	}
	278	+
	279	+	/// The theme for the frame at `now`.
	280	+	pub fn theme_at(&self, now: Instant) -> Theme {
	281	+	match &self.theme_fade {
	282	+	Some((from, t)) if t.is_active(now) => from.mix(&self.theme, t.value(now)),
	283	+	_ => self.theme.clone(),
	284	+	}
	285	+	}
	286	+
193	287		pub fn apply(&mut self, action: Action, now: Instant) -> Effects {
	288	+	self.apply_at(action, None, now)
	289	+	}
	290	+
	291	+	/// Apply an action; `anchor` (viewport pixels) is where mouse-driven zoom centres.
	292	+	pub fn apply_at(&mut self, action: Action, anchor: Option<[f32; 2]>, now: Instant) -> Effects {
194	293		let mut fx = Effects {
195	294		redraw: true,
196	295		..Effects::default()
197	296		};
198	297		let dur = self.dur();
199	298		let has_image = self.shown.is_some();
	299	+	let switch = \|s: Switch, cur: bool\| match s {
	300	+	Switch::Toggle => !cur,
	301	+	Switch::On => true,
	302	+	Switch::Off => false,
	303	+	};
200	304		match action {
201	305		Action::Next(n) => fx.navigated = self.queue.step(n as isize, self.settings.wrap),
202	306		Action::Prev(n) => fx.navigated = self.queue.step(-(n as isize), self.settings.wrap),
203	307		Action::First => fx.navigated = self.queue.goto(0),
204	308		Action::Last => fx.navigated = self.queue.goto(usize::MAX),
205	309		Action::Goto(n) => fx.navigated = self.queue.goto(n.saturating_sub(1)),
	310	+	Action::Random => {
	311	+	let len = self.queue.len();
	312	+	if len > 1 {
	313	+	let r = std::hash::BuildHasher::hash_one(
	314	+	&std::collections::hash_map::RandomState::new(),
	315	+	now,
	316	+	) as usize;
	317	+	// Any image but the current one.
	318	+	let i = (self.queue.index() + 1 + r % (len - 1)) % len;
	319	+	fx.navigated = self.queue.goto(i);
	320	+	}
	321	+	}
206	322		Action::Zoom(z) if has_image => {
207	323		let step = self.settings.zoom_step;
208	324		match z {
209		−	Zoom::In => self.view.zoom_by(step, None, now, dur),
210		−	Zoom::Out => self.view.zoom_by(1.0 / step, None, now, dur),
211		−	Zoom::Percent(p) => self.view.zoom_to(p / 100.0, None, now, dur),
	325	+	Zoom::In(n) => self.view.zoom_by(step.powi(n as i32), anchor, now, dur),
	326	+	Zoom::Out(n) => self.view.zoom_by(step.powi(-(n as i32)), anchor, now, dur),
	327	+	Zoom::Percent(p) => self.view.zoom_to(p / 100.0, anchor, now, dur),
212	328		}
213	329		}
214	330		Action::Fit(fit) if has_image => self.view.set_fit(fit, now, dur),
		@@ -227,11 +343,20 @@ impl AppState {
227	343		);
228	344		}
229	345		Action::AlphaBgCycle => self.alpha_bg = self.alpha_bg.next(),
230		−	Action::Fullscreen => fx.fullscreen = true,
231		−	Action::BarToggle => {
232		−	self.bar = !self.bar;
233		−	self.update_viewport();
234		−	fx.layout = true;
	346	+	Action::Fullscreen(s) => fx.fullscreen = Some(s),
	347	+	Action::Bar(s) => {
	348	+	let bar = switch(s, self.bar);
	349	+	if bar != self.bar {
	350	+	self.bar = bar;
	351	+	self.update_viewport();
	352	+	fx.layout = true;
	353	+	}
	354	+	}
	355	+	Action::Mode(ModeArg::Image) if self.mode == Mode::Image => fx.redraw = false,
	356	+	Action::Sort(key) => fx.sort = Some(key),
	357	+	Action::Reverse => {
	358	+	self.queue.reverse();
	359	+	fx.reordered = true;
235	360		}
236	361		Action::Reload => fx.reload = true,
237	362		Action::Remove => {
		@@ -240,8 +365,10 @@ impl AppState {
240	365		fx.navigated = true;
241	366		}
242	367		}
	368	+	Action::ReloadConfig => fx.reload_config = true,
	369	+	Action::Echo(msg) => self.notify(msg, MsgKind::Info, now),
243	370		Action::Cancel => self.message = None,
244		−	Action::Quit => fx.quit = true,
	371	+	Action::Quit \| Action::QuitNoOutput => fx.quit = true,
245	372		Action::Zoom(_)
246	373		\| Action::Fit(_)
247	374		\| Action::Pan(_)
		@@ -249,6 +376,37 @@ impl AppState {
249	376		\| Action::Center
250	377		\| Action::Rotate(_)
251	378		\| Action::Flip(_) => fx.redraw = false,
	379	+	// Parsed and bindable now; they arrive with later milestones.
	380	+	other @ (Action::NextMark
	381	+	\| Action::PrevMark
	382	+	\| Action::NextFrame
	383	+	\| Action::PrevFrame
	384	+	\| Action::Mark(_)
	385	+	\| Action::MarkAll
	386	+	\| Action::UnmarkAll
	387	+	\| Action::InvertMarks
	388	+	\| Action::Adjust(..)
	389	+	\| Action::Play(_)
	390	+	\| Action::Slideshow(_)
	391	+	\| Action::SlideshowDelay { .. }
	392	+	\| Action::Mode(_)
	393	+	\| Action::Visual
	394	+	\| Action::Info(_)
	395	+	\| Action::Help
	396	+	\| Action::Palette
	397	+	\| Action::Search
	398	+	\| Action::GridSize(_)
	399	+	\| Action::Filter(_)
	400	+	\| Action::FilterClear
	401	+	\| Action::Refresh
	402	+	\| Action::Open(_)
	403	+	\| Action::Run(_)) => {
	404	+	self.notify(
	405	+	format!("{} not available yet", other.name()),
	406	+	MsgKind::Info,
	407	+	now,
	408	+	);
	409	+	}
252	410		}
253	411		fx
254	412		}
		@@ -341,7 +499,7 @@ impl AppState {
341	499		self.loading_since = None;
342	500		}
343	501
344		−	/// Zoom by `steps` zoom steps around a viewport point (mouse wheel).
	502	+	/// Zoom by `steps` zoom steps (fractional for touchpads) around a viewport point.
345	503		pub fn zoom_at(&mut self, steps: f32, anchor: [f32; 2], now: Instant) {
346	504		if self.shown.is_some() {
347	505		let factor = self.settings.zoom_step.powf(steps);
		@@ -352,10 +510,20 @@ impl AppState {
352	510
353	511		pub fn notify(&mut self, text: impl Into<String>, kind: MsgKind, now: Instant) {
354	512		let secs = if kind == MsgKind::Error { 5 } else { 2 };
	513	+	self.notify_for(text, kind, now, Duration::from_secs(secs));
	514	+	}
	515	+
	516	+	pub fn notify_for(
	517	+	&mut self,
	518	+	text: impl Into<String>,
	519	+	kind: MsgKind,
	520	+	now: Instant,
	521	+	d: Duration,
	522	+	) {
355	523		self.message = Some(Message {
356	524		text: text.into(),
357	525		kind,
358		−	until: now + Duration::from_secs(secs),
	526	+	until: now + d,
359	527		});
360	528		}
361	529
		@@ -372,6 +540,10 @@ impl AppState {
372	540		pub fn is_animating(&self, now: Instant) -> bool {
373	541		self.view.is_animating(now)
374	542		\|\| self.fade.as_ref().is_some_and(\|f\| f.alpha.is_active(now))
	543	+	\|\| self
	544	+	.theme_fade
	545	+	.as_ref()
	546	+	.is_some_and(\|(_, t)\| t.is_active(now))
375	547		\|\| !self.holds.is_empty()
376	548		}
377	549
		@@ -398,6 +570,14 @@ impl AppState {
398	570		self.fade = None;
399	571		redraw = true;
400	572		}
	573	+	if self
	574	+	.theme_fade
	575	+	.as_ref()
	576	+	.is_some_and(\|(_, t)\| !t.is_active(now))
	577	+	{
	578	+	self.theme_fade = None;
	579	+	redraw = true;
	580	+	}
401	581		(redraw, next)
402	582		}
403	583		}
		@@ -428,7 +608,14 @@ mod tests {
428	608		fn bar_shrinks_the_image_area() {
429	609		let (mut s, now) = state(1);
430	610		assert_eq!(s.view.viewport(), [800.0, 600.0]);
431		−	assert!(s.apply(Action::BarToggle, now).layout);
	611	+	assert!(!s.apply(Action::Bar(Switch::On), now).layout);
	612	+	assert!(s.apply(Action::Bar(Switch::Toggle), now).layout);
	613	+	assert_eq!(s.view.viewport(), [800.0, 632.0]);
	614	+	assert!(!s.apply(Action::Bar(Switch::Off), now).layout);
	615	+	s.settings.ui_scale = 2.0;
	616	+	s.apply(Action::Bar(Switch::On), now);
	617	+	assert_eq!(s.view.viewport(), [800.0, 568.0]);
	618	+	s.apply(Action::Bar(Switch::Off), now);
432	619		assert_eq!(s.view.viewport(), [800.0, 632.0]);
433	620		}
434	621
		@@ -445,6 +632,44 @@ mod tests {
445	632		assert!(s.fade.is_none());
446	633		}
447	634
	635	+	#[test]
	636	+	fn theme_changes_crossfade() {
	637	+	use crate::config::theme::{Rgba, Theme};
	638	+	let (mut s, now) = state(1);
	639	+	let light = Theme::derive(
	640	+	Rgba::rgb(0xFFFFFF),
	641	+	Rgba::rgb(0x000000),
	642	+	Rgba::rgb(0xD71921),
	643	+	);
	644	+	s.set_theme(light.clone(), now);
	645	+	assert!(s.is_animating(now));
	646	+	let mid = s.theme_at(now + THEME_FADE / 2).background;
	647	+	assert!(mid.0[0] > 0 && mid.0[0] < 255, "{mid:?}");
	648	+	let later = now + THEME_FADE * 2;
	649	+	assert_eq!(s.theme_at(later), light);
	650	+	assert!(s.tick(later).0);
	651	+	assert!(!s.is_animating(later));
	652	+	// With animation off the switch is instant.
	653	+	s.settings.theme_fade = Duration::ZERO;
	654	+	s.set_theme(Theme::nothing_dark(), later);
	655	+	assert_eq!(s.theme_at(later), Theme::nothing_dark());
	656	+	}
	657	+
	658	+	#[test]
	659	+	fn unfinished_actions_say_so() {
	660	+	let (mut s, now) = state(2);
	661	+	let fx = s.apply(Action::Palette, now);
	662	+	assert!(!fx.navigated);
	663	+	assert_eq!(
	664	+	s.message.as_ref().map(\|m\| m.text.as_str()),
	665	+	Some("palette not available yet")
	666	+	);
	667	+	s.apply(Action::Echo("hi".into()), now);
	668	+	assert_eq!(s.message.as_ref().map(\|m\| m.text.as_str()), Some("hi"));
	669	+	assert!(s.apply(Action::Random, now).navigated);
	670	+	assert_eq!(s.queue.index(), 1);
	671	+	}
	672	+
448	673		#[test]
449	674		fn tapped_pan_moves_a_minimum_distance() {
450	675		let (mut s, now) = state(1);

		@@ -1,10 +1,23 @@
1	1		//! The file list: current index, ordering and navigation.
2	2
3	3		use std::cmp::Ordering;
	4	+	use std::collections::HashSet;
4	5		use std::path::{Path, PathBuf};
5	6
6		−	#[derive(Clone, Copy, Debug, PartialEq, Eq, clap::ValueEnum)]
	7	+	#[derive(
	8	+	Clone,
	9	+	Copy,
	10	+	Debug,
	11	+	Default,
	12	+	PartialEq,
	13	+	Eq,
	14	+	clap::ValueEnum,
	15	+	serde::Deserialize,
	16	+	serde::Serialize,
	17	+	)]
	18	+	#[serde(rename_all = "lowercase")]
7	19		pub enum SortKey {
	20	+	#[default]
8	21		Natural,
9	22		Name,
10	23		Mtime,
		@@ -126,6 +139,38 @@ impl Queue {
126	139		out
127	140		}
128	141
	142	+	pub fn files(&self) -> &[PathBuf] {
	143	+	&self.files
	144	+	}
	145	+
	146	+	/// Reverse the order, keeping the current file selected.
	147	+	pub fn reverse(&mut self) {
	148	+	self.files.reverse();
	149	+	self.index = self.clamp(self.files.len().saturating_sub(1) - self.index);
	150	+	}
	151	+
	152	+	/// Adopt a new order of the same files (a finished re-sort), keeping the current file.
	153	+	/// Files removed meanwhile stay removed; files added meanwhile go at the end.
	154	+	pub fn reorder(&mut self, order: Vec<PathBuf>) {
	155	+	let current = self.current().map(Path::to_path_buf);
	156	+	let have: HashSet<&PathBuf> = self.files.iter().collect();
	157	+	let mut files: Vec<PathBuf> = order.into_iter().filter(\|f\| have.contains(f)).collect();
	158	+	let placed: HashSet<&PathBuf> = files.iter().collect();
	159	+	let missing: Vec<PathBuf> = self
	160	+	.files
	161	+	.iter()
	162	+	.filter(\|f\| !placed.contains(f))
	163	+	.cloned()
	164	+	.collect();
	165	+	files.extend(missing);
	166	+	self.files = files;
	167	+	if let Some(cur) = current
	168	+	&& let Some(i) = self.files.iter().position(\|f\| *f == cur)
	169	+	{
	170	+	self.index = i;
	171	+	}
	172	+	}
	173	+
129	174		fn clamp(&self, i: usize) -> usize {
130	175		i.min(self.files.len().saturating_sub(1))
131	176		}
		@@ -288,6 +333,24 @@ mod tests {
288	333		assert_eq!(q.neighbours(2, true), vec![1]);
289	334		}
290	335
	336	+	#[test]
	337	+	fn reverse_and_reorder_keep_current() {
	338	+	let mut q = Queue::new(paths(&["a", "b", "c", "d"]), Some(Path::new("b")), 0);
	339	+	q.reverse();
	340	+	assert_eq!(q.files(), paths(&["d", "c", "b", "a"]));
	341	+	assert_eq!(q.current(), Some(Path::new("b")));
	342	+	q.remove(Path::new("d"));
	343	+	q.reorder(paths(&["a", "b", "d", "c"]));
	344	+	assert_eq!(q.files(), paths(&["a", "b", "c"]));
	345	+	assert_eq!(q.current(), Some(Path::new("b")));
	346	+	q.reorder(paths(&["c"]));
	347	+	assert_eq!(q.files(), paths(&["c", "a", "b"]));
	348	+	assert_eq!(q.current(), Some(Path::new("b")));
	349	+	let mut empty = Queue::default();
	350	+	empty.reverse();
	351	+	assert!(empty.is_empty());
	352	+	}
	353	+
291	354		#[test]
292	355		fn random_sort_is_a_permutation() {
293	356		let mut v = paths(&["a", "b", "c", "d", "e"]);

		@@ -14,9 +14,21 @@ pub const MAX_SCALE: f32 = 64.0;
14	14		/// Magnification above which `filter = auto` switches to nearest.
15	15		pub const NEAREST_ABOVE: f32 = 3.0;
16	16
17		−	#[derive(Clone, Copy, Debug, PartialEq, Eq, clap::ValueEnum)]
	17	+	#[derive(
	18	+	Clone,
	19	+	Copy,
	20	+	Debug,
	21	+	Default,
	22	+	PartialEq,
	23	+	Eq,
	24	+	clap::ValueEnum,
	25	+	serde::Deserialize,
	26	+	serde::Serialize,
	27	+	)]
	28	+	#[serde(rename_all = "lowercase")]
18	29		pub enum FitMode {
19	30		/// Fit, but never enlarge.
	31	+	#[default]
20	32		Down,
21	33		Fit,
22	34		Fill,

		@@ -46,7 +46,7 @@ pub fn scene<'a>(
46	46		now: Instant,
47	47		measure: &mut dyn FnMut(&TextItem) -> f32,
48	48		) -> Scene<'a> {
49		−	let sf = state.scale_factor();
	49	+	let sf = state.ui_scale();
50	50		let [w, h] = state.window();
51	51		let bar_h = state.bar_height();
52	52		let mut scene = Scene {
		@@ -138,7 +138,7 @@ fn status_bar(
138	138		bar_h: f32,
139	139		measure: &mut dyn FnMut(&TextItem) -> f32,
140	140		) {
141		−	let sf = state.scale_factor();
	141	+	let sf = state.ui_scale();
142	142		let pad = 16.0 * sf;
143	143		let y = h - bar_h * 0.5;
144	144		scene.prims.push(Prim::rect(
		@@ -185,7 +185,7 @@ fn status_bar(
185	185		info.push(format!("{:0digits$}/{count}", state.queue.index() + 1));
186	186		}
187	187		if !info.is_empty() {
188		−	spans.push((info.join(" "), theme.text_secondary));
	188	+	spans.push((info.join(" ").to_uppercase(), theme.text_secondary));
189	189		}
190	190		// Two spaces between segments, attached to the preceding span so colours stay put.
191	191		let n = spans.len();
		@@ -195,10 +195,8 @@ fn status_bar(
195	195		let mut right_w = 0.0;
196	196		if !spans.is_empty() {
197	197		let mut item = label("", theme.text_secondary, sf, w - pad, y, Align::Right);
198		−	item.spans = spans
199		−	.into_iter()
200		−	.map(\|(s, c)\| (s.to_uppercase(), c))
201		−	.collect();
	198	+	// Already in caps, except pending keys: `g` and `G` are different keys.
	199	+	item.spans = spans;
202	200		right_w = measure(&item);
203	201		scene.texts.push(item);
204	202		}

remage/92928dd

Add input and config: action grammar, keymap, live TOML config

remage92928dd