hex/src/rune_ui/windows_host.rs
Kit Langton f7a741cc8b
fix(settings): preserve other writers' changes when saving (#1747)
* fix(settings): merge edits through one persistence owner (t1533)

* fix(modes): focus the adopted correction without duplicating it (t1533)

* fix(settings): publish reversions even before the host saw the save (t1533)
2026-11-12 12:57:21 -08:00

271 lines
9.7 KiB
Rust

//! The Windows window's host: the runtime thread `windows_rune` starts in
//! this process, which owns the listener, model preparation, and updates.
//! Shortcut capture stays in the window: it polls the keyboard
//! state, because a modifier-only chord such as Ctrl+Win never reaches the
//! window as a key event.
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{self, Receiver};
use std::thread::JoinHandle;
use std::time::Duration;
use color_eyre::Result;
use super::settings::Chord;
use super::{HostState, ServiceView};
use crate::app_settings::HotkeyBinding;
use crate::desktop::i18n::tr;
use crate::windows::input::{ChordCapture, ChordPoll, NumpadWatch, WindowsHotkey};
use crate::windows::rune::RuntimeHandle;
pub(super) use crate::windows::rune::{Request, ShortcutTarget};
/// The window saves a recorded shortcut; the runtime restarts the listener.
pub(super) const HOST_SAVES_SHORTCUTS: bool = false;
pub(super) const RECORDS_KEY_EVENTS: bool = false;
/// Windows' Terminal paste (Ctrl+Shift+V) is a Labs feature, not a row in
/// General.
pub(super) const TERMINAL_PASTE: bool = false;
/// The window offers Quit Hex beside the tray's.
pub(super) const QUIT_IN_WINDOW: bool = true;
/// How often shortcut capture samples the keyboard.
const CHORD_POLL: Duration = Duration::from_millis(16);
/// The runtime is found through its own module; nothing is handed over.
#[derive(Default)]
pub(crate) struct Connect {
_nothing: (),
}
pub(super) struct Backend {
runtime: Option<RuntimeHandle>,
wake: Arc<dyn Fn() + Send + Sync>,
chords: Option<ChordWatch>,
}
impl Backend {
pub(super) fn connect(_: Connect, wake: Arc<dyn Fn() + Send + Sync>) -> Self {
let runtime = crate::windows::rune::runtime();
if let Some(runtime) = &runtime {
runtime.subscribe(wake.clone());
}
Self {
runtime,
wake,
chords: None,
}
}
pub(super) fn send(&mut self, request: Request) -> Result<()> {
match request {
Request::CaptureShortcutFor(_) => {
self.chords = Some(ChordWatch::start(self.wake.clone())?);
Ok(())
}
Request::CancelShortcut => {
self.chords = None;
Ok(())
}
request => match &self.runtime {
Some(runtime) => runtime.send(request),
None => Err(color_eyre::eyre::eyre!("Hex's runtime is not running")),
},
}
}
/// Saves `settings.json`, then asks the runtime to reload it.
pub(super) fn save(
&mut self,
base: &crate::app_settings::AppSettings,
settings: &crate::app_settings::AppSettings,
) -> Result<crate::app_settings::AppSettings> {
let saved = base.update(settings)?;
if let Err(error) = self.send(Request::ReloadSettings) {
tracing::warn!(%error, "settings saved but runtime reload could not be queued");
}
Ok(saved)
}
/// Asks the runtime to stop the listener and end the app, as the
/// tray's Quit Hex does.
pub(super) fn quit(&mut self) {
if let Err(error) = self.send(Request::Quit) {
tracing::warn!(%error, "could not quit Hex");
}
}
/// Rune hides the window (`keep_running`) and the runtime keeps
/// listening; without a tray Rune ends the app instead.
pub(super) fn closed(&mut self) {}
/// The runtime publishes into shared memory; nothing to pull.
pub(super) fn refresh(&mut self) {}
pub(super) fn error(&self) -> Option<String> {
self.runtime
.is_none()
.then(|| "Hex's runtime is not running".into())
}
pub(super) fn state(&self) -> Option<HostState> {
let published = self.runtime.as_ref()?.published()?;
Some(HostState {
view: ServiceView {
listener: published.listener.clone(),
operation_error: published.operation_error.clone(),
transcription: published.transcription.clone(),
update_status: published.update_status.clone(),
update_notes: published.update_notes.clone(),
update_blocked: published.update_blocked,
editing: false,
},
settings: published.settings.clone(),
})
}
pub(super) fn take_chord(&mut self) -> Option<Chord> {
let chord = self.chords.as_ref()?.results.try_recv().ok();
if matches!(chord, Some(Chord::Cancelled)) {
self.chords = None;
}
chord
}
}
/// Samples the keyboard on its own thread while the window records a
/// shortcut, with the listener's hook suspended so the current binding
/// can be recorded again.
struct ChordWatch {
results: Receiver<Chord>,
stop: Arc<AtomicBool>,
worker: Option<JoinHandle<()>>,
}
impl ChordWatch {
fn start(wake: Arc<dyn Fn() + Send + Sync>) -> Result<Self> {
crate::windows::input::set_capture_inhibited(true);
let (sender, results) = mpsc::channel();
let stop = Arc::new(AtomicBool::new(false));
let worker_stop = stop.clone();
let worker = std::thread::Builder::new()
.name("hex-chord-capture".into())
.spawn(move || {
let mut capture = ChordCapture::default();
let numpad = NumpadWatch::install();
// The modifiers last shown while the chord is in progress.
let mut shown = capture.held();
while !worker_stop.load(Ordering::Relaxed) {
std::thread::sleep(CHORD_POLL);
if let Some(numpad) = &numpad {
numpad.pump();
}
// Keys typed into another application never rebind a
// shortcut.
if !crate::windows::input::app_is_foreground() {
continue;
}
let chord = match capture.poll() {
ChordPoll::Pending if capture.held() == shown => continue,
ChordPoll::Pending => {
shown = capture.held();
Chord::Held(HotkeyBinding::from(&shown).modifiers)
}
ChordPoll::Cancelled => Chord::Cancelled,
ChordPoll::Unsupported => {
shown = capture.held();
Chord::Captured(Err(tr("Unsupported key")))
}
ChordPoll::Captured(hotkey) => {
// A rejected chord: record the next one from
// scratch.
capture = ChordCapture::default();
shown = capture.held();
Chord::Captured(Ok(HotkeyBinding::from(&hotkey)))
}
};
let cancelled = matches!(chord, Chord::Cancelled);
if sender.send(chord).is_err() {
return;
}
wake();
if cancelled {
return;
}
}
});
match worker {
Ok(worker) => Ok(Self {
results,
stop,
worker: Some(worker),
}),
Err(error) => {
crate::windows::input::set_capture_inhibited(false);
Err(error.into())
}
}
}
}
impl Drop for ChordWatch {
fn drop(&mut self) {
self.stop.store(true, Ordering::Relaxed);
if let Some(worker) = self.worker.take() {
let _ = worker.join();
}
crate::windows::input::set_capture_inhibited(false);
}
}
/// A dictation shortcut needs a modifier, a function key, or a mouse button,
/// and Paste Last fires on a key press.
pub(super) fn validate_hotkey(
target: ShortcutTarget,
binding: &HotkeyBinding,
) -> Result<(), &'static str> {
if target != ShortcutTarget::Dictation && binding.key.is_none() {
return Err(tr("Add a key"));
}
// Hex takes the cancel key only while a recording runs, so a key alone,
// such as Escape, never keeps it from other apps.
if target == ShortcutTarget::Cancel {
return WindowsHotkey::from(binding)
.key
.as_deref()
.map_or(Ok(0), crate::windows::input::virtual_key)
.map(|_| ())
.map_err(|_| tr("Unsupported key"));
}
WindowsHotkey::from(binding)
.validate()
.map_err(|_| tr("Add a modifier"))
}
/// The listener's retained history, shared with the window.
pub(super) fn history(
_: &Connect,
retention: crate::history::HistoryRetention,
) -> Option<crate::history::History> {
match crate::windows::rune::runtime() {
Some(runtime) => runtime.history(),
None => crate::history::History::open_default(retention)
.inspect_err(|error| tracing::warn!(%error, "could not open retained history"))
.ok(),
}
}
/// UI Automation reports the foreground application.
pub(super) fn focused_application_known() -> bool {
true
}
/// The current-user Run key is the source of truth, never `settings.json`.
pub(super) fn launch_at_login() -> Option<Result<bool, String>> {
Some(crate::windows::login_item::is_enabled().map_err(|error| format!("{error:#}")))
}
pub(super) fn set_launch_at_login(enabled: bool) -> Result<bool, String> {
crate::windows::login_item::set_enabled(enabled).map_err(|error| format!("{error:#}"))?;
crate::windows::login_item::is_enabled().map_err(|error| format!("{error:#}"))
}