tawasuyu/brahman
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(mirada): keymap configurable en RON, recargable en caliente

Browse Source 
Los atajos de teclado dejan de estar cableados: ahora son un Keymap
configurable que vive sólo en el Cerebro. El Cuerpo nunca lo ve — sólo
recibe la lista de cadenas a interceptar (GrabKeys) y devuelve la
pulsada; es Desktop quien la traduce. Esa separación (qué interceptar
vs. qué significa) hace innecesario cualquier candado o Arc.

mirada-brain:
- keymap.rs — Keymap: from_ron/to_ron, load/save, load_or_init (escribe
  un archivo por defecto documentado si falta; default sin pisar si está
  corrupto), default_path (~/.config/mirada/keymap.ron), y watch sobre
  notify para la recarga en caliente (KeymapWatch).
- DesktopAction: Display + FromStr — vocabulario textual estable
  ("focus-next", "layout:grid", "workspace:3"); evita los guiones que
  romperían el RON de un enum.
- Desktop: with_keymap, set_keymap (cambio en caliente -> nuevo GrabKeys).
- Ejemplo keymap-default: imprime el archivo por defecto en RON.

Apps: mirada y mirada-compositor (modo embebido) cargan el keymap del
usuario al arrancar y lo recargan en caliente cuando el archivo cambia.

Disco RON, cable postcard (sólo la lista de cadenas), sin ejecutable
configurador. mirada-brain: 17 -> 29 tests.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
sergio
2026-05-21 00:04:11 +00:00
parent 51398f89cf
commit 8204852e3a
13 changed files with 713 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.lock
Generated
+19
View File
@@ -1589,6 +1589,9 @@ name = "bitflags"
version = "2.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
dependencies = [
"serde_core",
]
[[package]]
name = "bitmaps"
@@ -7712,8 +7715,12 @@ dependencies = [
name = "mirada-brain"
version = "0.1.0"
dependencies = [
"directories",
"mirada-layout",
"mirada-protocol",
"notify",
"ron",
"serde",
]
[[package]]
@@ -10973,6 +10980,18 @@ version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4e27ee8bb91ca0adcf0ecb116293afa12d393f9c2b9b9cd54d33e8078fe19839"
[[package]]
name = "ron"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94"
dependencies = [
"base64 0.21.7",
"bitflags 2.11.1",
"serde",
"serde_derive",
]
[[package]]
name = "roxmltree"
version = "0.20.0"
Cargo.toml
+1
View File
@@ -305,6 +305,7 @@ serde_json = "1"
serde-big-array = "0.5"
postcard = { version = "1", features = ["use-std"] }
toml = "0.8"
ron = "0.8"
bincode = "1"
base64 = "0.22"
crates/apps/mirada-compositor/README.md
+18 -2
View File
@@ -60,10 +60,26 @@ WAYLAND_DISPLAY=wayland-1 foot # o weston-terminal, alacritty, …
```
Las ventanas se teselan solas. El teclado, con la ventana del compositor
enfocada, maneja el escritorio con atajos `Super+…` (los que registra el
Cerebro: foco `Super+j/k`, layout `Super+Tab`, escritorios `Super+1..9`).
enfocada, maneja el escritorio con atajos `Super+…`: foco `Super+j/k`,
ciclar layout `Super+space`, escritorios `Super+1..9`, cerrar `Super+q`.
Cierra la ventana del compositor para salir.
## Atajos de teclado
Los atajos son configurables en RON: `~/.config/mirada/keymap.ron`. En
modo autónomo, el Cuerpo lo carga al arrancar (si no existe, escribe uno
por defecto documentado) y lo **recarga en caliente** — edita el archivo,
guarda, y los atajos cambian sin reiniciar. En modo enlazado el keymap es
asunto del Cerebro (la app `mirada`).
```sh
cargo run -p mirada-brain --example keymap-default # ver el formato
```
El compositor en sí no interpreta atajos: sólo intercepta las
combinaciones que el Cerebro le pide (`GrabKeys`) y le devuelve la
pulsada. *Qué significa* cada una lo decide `mirada-brain`. Ver el SDD.
## Qué implementa
`wl_compositor`, `xdg_shell` (toplevels y popups), `wl_shm`, `wl_seat`
crates/apps/mirada-compositor/src/main.rs
+42 -2
View File
@@ -59,7 +59,7 @@ use smithay::{
};
use mirada_body::{BodyOp, BodyState};
use mirada_brain::{BodyEvent, BrainCommand, Desktop};
use mirada_brain::{BodyEvent, BrainCommand, Desktop, Keymap};
use mirada_link::BodyLink;
// ---------------------------------------------------------------------
@@ -435,6 +435,10 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
let mut seat_state = SeatState::new();
let seat = seat_state.new_wl_seat(&dh, "mirada");
// El keymap del usuario (`~/.config/mirada/keymap.ron`). Sólo lo usa
// el Cerebro embebido; con un Cerebro enlazado, el keymap es asunto suyo.
let keymap_path = Keymap::default_path();
// Elige el Cerebro: enlazado si `MIRADA_SOCKET` está puesto.
let brain = match std::env::var("MIRADA_SOCKET") {
Ok(path) => {
@@ -445,7 +449,11 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
}
Err(_) => {
println!("mirada-compositor · modo autónomo (Cerebro embebido).");
Brain::Embedded(Desktop::new())
let keymap = match &keymap_path {
Some(p) => Keymap::load_or_init(p),
None => Keymap::default(),
};
Brain::Embedded(Desktop::with_keymap(keymap))
}
};
@@ -475,6 +483,16 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
state.apply_commands(vec![grab]);
}
// Vigilancia del keymap para recargarlo en caliente — sólo tiene
// sentido con el Cerebro embebido.
let keymap_watch = match (&state.brain, &keymap_path) {
(Brain::Embedded(_), Some(p)) => Keymap::watch(p).ok(),
_ => None,
};
if keymap_watch.is_some() {
println!("mirada-compositor · vigilando el keymap (recarga en caliente).");
}
// El backend gráfico va primero. winit abre la ventana del compositor
// dentro de tu sesión gráfica anfitriona, y para encontrarla lee
// `WAYLAND_DISPLAY` / `DISPLAY` del entorno. Si publicáramos antes
@@ -571,6 +589,28 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
// 2 · Comandos de un Cerebro enlazado.
state.brain_poll();
// 2 bis · Recarga del keymap si el archivo cambió en disco.
if keymap_watch.as_ref().is_some_and(|w| w.changed()) {
if let Some(path) = &keymap_path {
match Keymap::load(path) {
Ok(km) => {
let cmd = if let Brain::Embedded(d) = &mut state.brain {
Some(d.set_keymap(km))
} else {
None
};
if let Some(cmd) = cmd {
state.apply_commands(vec![cmd]);
}
println!("mirada-compositor · keymap recargado.");
}
Err(e) => eprintln!(
"mirada-compositor · keymap inválido, conservo el anterior: {e}"
),
}
}
}
// 3 · Composición de las superficies en sus rectángulos.
let size = backend.window_size();
let damage: Rectangle<i32, smithay::utils::Physical> = Rectangle::from_size(size);
crates/apps/mirada/src/main.rs
+51 -7
View File
@@ -25,6 +25,7 @@
//! Shift+j / k mueve la enfocada Ctrl+1..9 enviar a escritorio
//! ```
use std::path::PathBuf;
use std::time::Duration;
use gpui::{
@@ -32,7 +33,8 @@ use gpui::{
SharedString, Window,
};
use mirada_brain::{
BodyEvent, BrainCommand, Desktop, DesktopAction, LayoutMode, WindowId, WindowPlacement,
BodyEvent, BrainCommand, Desktop, DesktopAction, Keymap, KeymapWatch, LayoutMode, WindowId,
WindowPlacement,
};
use mirada_link::BrainLink;
use nahual_launcher::launch_app;
@@ -62,18 +64,40 @@ struct Mirada {
note: SharedString,
focus: FocusHandle,
focused_once: bool,
/// Ruta del keymap del usuario, para recargarlo en caliente.
keymap_path: Option<PathBuf>,
/// Vigía del keymap; `None` en simulación o si no hay archivo.
keymap_watch: Option<KeymapWatch>,
}
impl Mirada {
fn new(cx: &mut Context<Self>) -> Self {
// Keymap del usuario (~/.config/mirada/keymap.ron): define los
// atajos que el Cuerpo intercepta y nos devuelve como `Keybind`.
let keymap_path = Keymap::default_path();
let keymap = match &keymap_path {
Some(p) => Keymap::load_or_init(p),
None => Keymap::default(),
};
let link = connect_body();
// Vigilar el keymap sólo tiene sentido con un Cuerpo conectado;
// en simulación, mirada usa las teclas de su propia ventana.
let keymap_watch = if link.is_some() {
keymap_path.as_deref().and_then(|p| Keymap::watch(p).ok())
} else {
None
};
let mut app = Self {
desktop: Desktop::new(),
desktop: Desktop::with_keymap(keymap),
placements: Vec::new(),
next_id: 1,
link: connect_body(),
link,
note: SharedString::from("listo"),
focus: cx.focus_handle(),
focused_once: false,
keymap_path,
keymap_watch,
};
if let Some(link) = app.link.as_mut() {
// Registra los atajos globales en el Cuerpo.
@@ -102,10 +126,15 @@ impl Mirada {
Some(link) => link.drain(),
None => Vec::new(),
};
if !events.is_empty() {
for ev in events {
app.feed(ev);
}
let had_events = !events.is_empty();
let keymap_changed = app.keymap_watch.as_ref().is_some_and(|w| w.changed());
if keymap_changed {
app.reload_keymap();
}
for ev in events {
app.feed(ev);
}
if had_events || keymap_changed {
cx.notify();
}
});
@@ -141,6 +170,21 @@ impl Mirada {
self.dispatch(cmds);
}
/// Recarga el keymap del disco y re-registra los atajos en el Cuerpo.
fn reload_keymap(&mut self) {
let Some(path) = self.keymap_path.clone() else {
return;
};
match Keymap::load(&path) {
Ok(km) => {
let cmd = self.desktop.set_keymap(km);
self.dispatch(vec![cmd]);
self.note = SharedString::from("keymap recargado");
}
Err(e) => self.note = SharedString::from(format!("keymap inválido: {e}")),
}
}
/// Reparte los comandos del Cerebro: actualiza lo pintado y, o bien
/// los manda al Cuerpo, o bien —en simulación— cierra las ventanas
/// por su cuenta (no hay nadie que devuelva el `WindowClosed`).
crates/modules/mirada/SDD.md
+28 -2
View File
@@ -56,7 +56,8 @@ ejecuta operaciones de geometría".
`placements(&Workspace, Rect)`.
- **`mirada-brain`** — `Desktop`: salidas, 9 escritorios virtuales,
registro de ventanas. `on_event(BodyEvent) -> Vec<BrainCommand>`;
`DesktopAction` + mapa de teclas estilo *tiling WM* (`Super`).
`DesktopAction` + `Keymap` configurable. `set_keymap` lo cambia en
caliente y devuelve el `GrabKeys` a reenviar.
- **`mirada-link`** — `Link<Out,In>` sobre socket Unix; hilo lector de
fondo + canal `mpsc` para sondeo no bloqueante. `BrainLink`/`BodyLink`,
`connected_pair` (socketpair), `connect`/`listen` por ruta.
@@ -69,6 +70,31 @@ ejecuta operaciones de geometría".
conecta a un Cuerpo; sin él corre en **simulación** (ventanas
sintéticas, teclado de la propia ventana).
## Atajos de teclado configurables
El keymap vive **sólo en el Cerebro** (`mirada-brain::Keymap`). El Cuerpo
nunca lo ve: recibe únicamente la lista de cadenas a interceptar en un
`GrabKeys`, hace un `Vec::contains` ciego y devuelve la combinación
pulsada como `Keybind`; es `Desktop` quien la traduce a `DesktopAction`.
Esa separación —*qué* interceptar (lista barata, Cuerpo) vs. *qué
significa* (el mapa, Cerebro)— hace innecesario cualquier candado o
`Arc`: el mapa es monohilo y la lista se reemplaza de golpe.
- **Disco** — RON de texto en `~/.config/mirada/keymap.ron`, editable a
mano y versionable. La app lo crea documentado en el primer arranque;
si está corrupto, avisa y usa el de por defecto sin pisar el archivo.
- **Cable** — sólo viaja la lista de cadenas (`GrabKeys`), vía el marco
`postcard` que ya existe. No hay formato binario de configuración.
- **Vocabulario** — la acción es una cadena estable (`"focus-next"`,
`"layout:grid"`, `"workspace:3"`): `DesktopAction: Display + FromStr`.
- **Recarga en caliente** — `Keymap::watch` (sobre `notify`) vigila el
archivo; al cambiar, el dueño del `Desktop` recarga, llama a
`set_keymap` y reenvía el `GrabKeys`. Sin reiniciar.
- **Configurador** — no hay ejecutable aparte: el editor de texto del
usuario, y la app `mirada` (que a futuro puede dibujar un editor visual
sobre el mismo API `Keymap`). `cargo run -p mirada-brain --example
keymap-default` imprime el archivo por defecto.
## Dependencias
- Todos los `lib` con `#![forbid(unsafe_code)]`. Cero Wayland, cero
@@ -78,7 +104,7 @@ ejecuta operaciones de geometría".
## Estado
Implementado y verde: `mirada-layout` (22 tests), `mirada-protocol`
(9), `mirada-brain` (17), `mirada-link` (7), `mirada-body` (13), y la
(9), `mirada-brain` (29), `mirada-link` (7), `mirada-body` (13), y la
app `mirada` (compila; verificación visual manual).
El **Cuerpo** ya existe: `mirada-compositor` es un compositor Wayland
crates/modules/mirada/mirada-brain/Cargo.toml
+4
View File
@@ -10,3 +10,7 @@ description = "mirada — orquestador de escritorio del compositor: mantiene sal
[dependencies]
mirada-layout = { path = "../mirada-layout" }
mirada-protocol = { path = "../mirada-protocol" }
serde = { workspace = true }
ron = { workspace = true }
directories = { workspace = true }
notify = { workspace = true }
crates/modules/mirada/mirada-brain/examples/keymap-default.rs
+11
View File
@@ -0,0 +1,11 @@
//! Imprime el keymap por defecto de mirada en formato RON — exactamente
//! lo que la app escribe la primera vez en `~/.config/mirada/keymap.ron`.
//!
//! ```sh
//! cargo run -p mirada-brain --example keymap-default
//! cargo run -p mirada-brain --example keymap-default > ~/.config/mirada/keymap.ron
//! ```
fn main() {
print!("{}", mirada_brain::Keymap::default().documented_ron());
}
crates/modules/mirada/mirada-brain/src/action.rs
+137
View File
@@ -3,6 +3,13 @@
//! Una [`DesktopAction`] es una orden de alto nivel del usuario, ya
//! desligada de la tecla concreta: el [`Desktop`](crate::Desktop) las
//! aplica sin saber qué combinación las disparó.
//!
//! Cada acción tiene una **forma textual** estable ([`Display`] /
//! [`FromStr`]) — `"focus-next"`, `"layout:grid"`, `"workspace:3"` — que
//! es el vocabulario del keymap configurable en RON (ver [`crate::keymap`]).
use std::fmt;
use std::str::FromStr;
use mirada_layout::LayoutMode;
@@ -34,6 +41,93 @@ pub enum DesktopAction {
Quit,
}
/// El nombre RON-seguro de un modo de teselado (sin guiones problemáticos
/// para identificadores: aquí van como valor de cadena, no de enum).
fn layout_slug(mode: LayoutMode) -> &'static str {
match mode {
LayoutMode::MasterStack => "master-stack",
LayoutMode::Monocle => "monocle",
LayoutMode::Grid => "grid",
LayoutMode::Columns => "columns",
}
}
/// Modo de teselado desde su `slug`.
fn layout_from_slug(slug: &str) -> Option<LayoutMode> {
Some(match slug {
"master-stack" => LayoutMode::MasterStack,
"monocle" => LayoutMode::Monocle,
"grid" => LayoutMode::Grid,
"columns" => LayoutMode::Columns,
_ => return None,
})
}
impl fmt::Display for DesktopAction {
/// La forma textual estable de la acción — el vocabulario del keymap.
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
DesktopAction::FocusNext => f.write_str("focus-next"),
DesktopAction::FocusPrev => f.write_str("focus-prev"),
DesktopAction::MoveForward => f.write_str("move-forward"),
DesktopAction::MoveBackward => f.write_str("move-backward"),
DesktopAction::CloseFocused => f.write_str("close-focused"),
DesktopAction::CycleLayout => f.write_str("cycle-layout"),
DesktopAction::SetLayout(m) => write!(f, "layout:{}", layout_slug(*m)),
// Los escritorios se numeran 1-based de cara al usuario.
DesktopAction::SwitchWorkspace(n) => write!(f, "workspace:{}", n + 1),
DesktopAction::SendToWorkspace(n) => write!(f, "send-to-workspace:{}", n + 1),
DesktopAction::Quit => f.write_str("quit"),
}
}
}
impl FromStr for DesktopAction {
/// Mensaje de error ya formateado, listo para mostrar al usuario.
type Err = String;
fn from_str(s: &str) -> Result<Self, String> {
let s = s.trim();
Ok(match s {
"focus-next" => Self::FocusNext,
"focus-prev" => Self::FocusPrev,
"move-forward" => Self::MoveForward,
"move-backward" => Self::MoveBackward,
"close-focused" => Self::CloseFocused,
"cycle-layout" => Self::CycleLayout,
"quit" => Self::Quit,
_ => {
if let Some(slug) = s.strip_prefix("layout:") {
Self::SetLayout(
layout_from_slug(slug)
.ok_or_else(|| format!("modo de teselado desconocido: '{slug}'"))?,
)
} else if let Some(n) = s.strip_prefix("send-to-workspace:") {
Self::SendToWorkspace(parse_workspace(n)?)
} else if let Some(n) = s.strip_prefix("workspace:") {
Self::SwitchWorkspace(parse_workspace(n)?)
} else {
return Err(format!("acción desconocida: '{s}'"));
}
}
})
}
}
/// Parsea el número de escritorio del keymap (1-based) a índice (0-based),
/// acotado a [`WORKSPACE_COUNT`].
fn parse_workspace(s: &str) -> Result<usize, String> {
let n: usize = s
.trim()
.parse()
.map_err(|_| format!("número de escritorio inválido: '{s}'"))?;
if (1..=WORKSPACE_COUNT).contains(&n) {
Ok(n - 1)
} else {
Err(format!("escritorio fuera de rango (1..={WORKSPACE_COUNT}): {n}"))
}
}
/// Mapa de teclas por defecto, estilo *tiling WM* (modificador `Super`).
///
/// Las cadenas deben coincidir literalmente con las que el Cuerpo emite
@@ -92,4 +186,47 @@ mod tests {
.any(|(_, a)| *a == DesktopAction::SendToWorkspace(n)));
}
}
#[test]
fn every_default_action_round_trips_through_its_text_form() {
for (_, action) in default_keymap() {
let text = action.to_string();
let back: DesktopAction = text.parse().unwrap();
assert_eq!(action, back, "no redondea: {text}");
}
}
#[test]
fn every_layout_mode_round_trips() {
for mode in [
LayoutMode::MasterStack,
LayoutMode::Monocle,
LayoutMode::Grid,
LayoutMode::Columns,
] {
let a = DesktopAction::SetLayout(mode);
assert_eq!(a, a.to_string().parse().unwrap());
}
}
#[test]
fn workspace_actions_are_one_based_in_text() {
assert_eq!(DesktopAction::SwitchWorkspace(0).to_string(), "workspace:1");
assert_eq!(
"workspace:1".parse::<DesktopAction>().unwrap(),
DesktopAction::SwitchWorkspace(0)
);
assert_eq!(
"send-to-workspace:9".parse::<DesktopAction>().unwrap(),
DesktopAction::SendToWorkspace(8)
);
}
#[test]
fn out_of_range_or_unknown_actions_are_rejected() {
assert!("workspace:0".parse::<DesktopAction>().is_err());
assert!("workspace:99".parse::<DesktopAction>().is_err());
assert!("layout:fractal".parse::<DesktopAction>().is_err());
assert!("teleport".parse::<DesktopAction>().is_err());
}
}
crates/modules/mirada/mirada-brain/src/desktop.rs
+50 -12
View File
@@ -5,7 +5,8 @@ use std::collections::HashMap;
use mirada_layout::{LayoutMode, LayoutParams, Rect, WindowId, Workspace};
use mirada_protocol::{placements, BodyEvent, BrainCommand, OutputId};
use crate::action::{default_keymap, DesktopAction, WORKSPACE_COUNT};
use crate::action::{DesktopAction, WORKSPACE_COUNT};
use crate::keymap::Keymap;
/// Lo que el Cerebro sabe de una ventana: su identidad de aplicación.
#[derive(Debug, Clone, PartialEq, Eq, Default)]
@@ -32,8 +33,8 @@ pub struct Desktop {
active: usize,
/// Identidad de cada ventana conocida.
windows: HashMap<WindowId, WindowInfo>,
/// Atajos globales → acción.
keymap: Vec<(String, DesktopAction)>,
/// Atajos globales → acción. Configurable, recargable en caliente.
keymap: Keymap,
}
impl Default for Desktop {
@@ -46,6 +47,12 @@ impl Desktop {
/// Escritorio recién arrancado: sin salidas ni ventanas, con los
/// escritorios virtuales vacíos y el mapa de teclas por defecto.
pub fn new() -> Self {
Self::with_keymap(Keymap::default())
}
/// Como [`Desktop::new`], pero con un keymap dado — el que la app
/// cargó del archivo de configuración del usuario.
pub fn with_keymap(keymap: Keymap) -> Self {
let workspaces = (0..WORKSPACE_COUNT)
.map(|_| Workspace::new(LayoutParams::default()))
.collect();
@@ -54,14 +61,26 @@ impl Desktop {
workspaces,
active: 0,
windows: HashMap::new(),
keymap: default_keymap(),
keymap,
}
}
/// El comando que registra los atajos globales en el Cuerpo. La app
/// GPUI lo envía una vez, al conectar.
/// lo envía al conectar, y de nuevo tras cada recarga del keymap.
pub fn grab_keys(&self) -> BrainCommand {
BrainCommand::GrabKeys(self.keymap.iter().map(|(k, _)| k.clone()).collect())
BrainCommand::GrabKeys(self.keymap.grab_list())
}
/// Reemplaza el keymap en caliente. Devuelve el [`BrainCommand`] que
/// el dueño debe enviar al Cuerpo para reajustar qué teclas intercepta.
pub fn set_keymap(&mut self, keymap: Keymap) -> BrainCommand {
self.keymap = keymap;
self.grab_keys()
}
/// El keymap vigente — para un HUD o un editor visual de atajos.
pub fn keymap(&self) -> &Keymap {
&self.keymap
}
/// Geometría de la salida primaria, si hay alguna conectada.
@@ -111,12 +130,10 @@ impl Desktop {
Vec::new()
}
}
BodyEvent::Keybind(key) => {
match self.keymap.iter().find(|(k, _)| *k == key).map(|(_, a)| *a) {
Some(action) => self.apply(action),
None => Vec::new(),
}
}
BodyEvent::Keybind(key) => match self.keymap.lookup(&key) {
Some(action) => self.apply(action),
None => Vec::new(),
},
}
}
@@ -279,6 +296,27 @@ mod tests {
}
}
#[test]
fn set_keymap_swaps_the_bindings_and_regrabs() {
let mut d = desktop_with_screen();
for id in [1, 2, 3] {
open(&mut d, id);
}
// El keymap por defecto no usa Alt.
assert!(d.on_event(BodyEvent::Keybind("Alt+x".into())).is_empty());
// Cargamos un keymap a medida; el comando devuelto re-registra grabs.
let custom = crate::Keymap::from_ron(r#"( bindings: { "Alt+x": "focus-prev" } )"#).unwrap();
match d.set_keymap(custom) {
BrainCommand::GrabKeys(keys) => assert_eq!(keys, vec!["Alt+x".to_string()]),
other => panic!("se esperaba GrabKeys, no {other:?}"),
}
// Ahora «Alt+x» sí mueve el foco, y «Super+j» ya no.
assert_eq!(d.focused_window(), Some(3));
d.on_event(BodyEvent::Keybind("Alt+x".into()));
assert_eq!(d.focused_window(), Some(2));
assert!(d.on_event(BodyEvent::Keybind("Super+j".into())).is_empty());
}
#[test]
fn without_a_screen_nothing_is_placed() {
let mut d = Desktop::new();
crates/modules/mirada/mirada-brain/src/keymap.rs
+339
View File
@@ -0,0 +1,339 @@
//! El keymap configurable — atajos del escritorio en RON, recargables en
//! caliente.
//!
//! # Dónde vive el keymap
//!
//! Sólo en el Cerebro. El Cuerpo (`mirada-compositor`) **nunca** ve este
//! mapa: lo único que recibe es la lista de cadenas a interceptar
//! ([`grab_list`](Keymap::grab_list)) dentro de un
//! [`BrainCommand::GrabKeys`](mirada_protocol::BrainCommand::GrabKeys). El
//! Cuerpo hace un `Vec::contains` ciego y devuelve la combinación pulsada
//! como [`BodyEvent::Keybind`](mirada_protocol::BodyEvent::Keybind); es el
//! [`Desktop`](crate::Desktop) quien la traduce a una
//! [`DesktopAction`]. Esa separación —*qué* interceptar vs. *qué
//! significa*— es la que hace innecesario cualquier candado o `Arc`:
//! el mapa es monohilo aquí y la lista viaja de golpe en un solo mensaje.
//!
//! # Persistencia
//!
//! En disco es RON de texto (`~/.config/mirada/keymap.ron`), editable a
//! mano y versionable. El cable sólo lleva la lista de cadenas; no hay
//! formato binario de configuración. Hay un único ejecutable que hace de
//! "configurador": la app `mirada`, que carga este archivo al arrancar.
//!
//! # Recarga en caliente
//!
//! [`Keymap::watch`] devuelve un [`KeymapWatch`] que vigila el archivo;
//! cuando cambia, el dueño del [`Desktop`](crate::Desktop) recarga el
//! keymap, llama a [`Desktop::set_keymap`](crate::Desktop::set_keymap) y
//! reenvía el `GrabKeys` resultante. Sin reiniciar nada.
use std::collections::BTreeMap;
use std::fmt;
use std::io;
use std::path::{Path, PathBuf};
use std::sync::mpsc;
use serde::{Deserialize, Serialize};
use crate::action::{default_keymap, DesktopAction};
/// Atajos del escritorio: combinación canónica → acción.
///
/// La combinación es la cadena que canoniza el Cuerpo (`"Super+Shift+j"`,
/// `"Super+space"`…). El keymap es lo único que la traduce a una
/// [`DesktopAction`].
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Keymap {
bindings: BTreeMap<String, DesktopAction>,
}
impl Default for Keymap {
/// El keymap por defecto, estilo *tiling WM* (ver [`default_keymap`]).
fn default() -> Self {
Self {
bindings: default_keymap().into_iter().collect(),
}
}
}
impl Keymap {
/// Construye un keymap a partir de pares `(combinación, acción)`.
pub fn from_pairs(pairs: impl IntoIterator<Item = (String, DesktopAction)>) -> Self {
Self {
bindings: pairs.into_iter().collect(),
}
}
/// La acción asociada a una combinación, si la hay.
pub fn lookup(&self, combo: &str) -> Option<DesktopAction> {
self.bindings.get(combo).copied()
}
/// Las combinaciones a interceptar — el contenido de un `GrabKeys`.
pub fn grab_list(&self) -> Vec<String> {
self.bindings.keys().cloned().collect()
}
/// Todos los atajos, en orden de combinación.
pub fn bindings(&self) -> &BTreeMap<String, DesktopAction> {
&self.bindings
}
/// Cuántos atajos hay.
pub fn len(&self) -> usize {
self.bindings.len()
}
/// `true` si no hay ningún atajo.
pub fn is_empty(&self) -> bool {
self.bindings.is_empty()
}
// --- RON ----------------------------------------------------------
/// Parsea un keymap desde el texto RON de un archivo de configuración.
pub fn from_ron(text: &str) -> Result<Keymap, KeymapError> {
let file: KeymapFile = ron::from_str(text)
.map_err(|e| KeymapError::Parse(format!("RON inválido: {e}")))?;
let mut bindings = BTreeMap::new();
for (combo, action) in file.bindings {
let parsed = action
.parse::<DesktopAction>()
.map_err(|e| KeymapError::Parse(format!("atajo \"{combo}\": {e}")))?;
bindings.insert(combo, parsed);
}
Ok(Keymap { bindings })
}
/// Serializa el keymap a RON (sin la cabecera de documentación).
pub fn to_ron(&self) -> String {
let file = KeymapFile {
bindings: self
.bindings
.iter()
.map(|(k, v)| (k.clone(), v.to_string()))
.collect(),
};
ron::ser::to_string_pretty(&file, ron::ser::PrettyConfig::default())
.expect("un KeymapFile de cadenas siempre serializa")
}
// --- Disco --------------------------------------------------------
/// La ruta canónica del keymap del usuario: `~/.config/mirada/keymap.ron`.
/// `None` si no se puede determinar el directorio de configuración.
pub fn default_path() -> Option<PathBuf> {
directories::ProjectDirs::from("", "", "mirada")
.map(|d| d.config_dir().join("keymap.ron"))
}
/// Carga un keymap desde un archivo RON.
pub fn load(path: &Path) -> Result<Keymap, KeymapError> {
let text = std::fs::read_to_string(path)?;
Keymap::from_ron(&text)
}
/// El keymap como RON con la cabecera de documentación — exactamente
/// lo que [`save`](Keymap::save) escribe en disco.
pub fn documented_ron(&self) -> String {
format!("{KEYMAP_HEADER}\n{}", self.to_ron())
}
/// Escribe el keymap a `path` como RON documentado (con cabecera de
/// comentarios), creando el directorio padre si falta.
pub fn save(&self, path: &Path) -> Result<(), KeymapError> {
if let Some(dir) = path.parent() {
std::fs::create_dir_all(dir)?;
}
std::fs::write(path, self.documented_ron())?;
Ok(())
}
/// Carga el keymap del usuario con un fallback amable:
///
/// - si el archivo no existe, escribe uno por defecto documentado y lo
/// devuelve (así el usuario lo descubre y lo puede editar);
/// - si existe pero está corrupto, avisa por `stderr` y devuelve el
/// keymap por defecto **sin tocar el archivo** (no se pierde el
/// trabajo del usuario por un error de sintaxis).
pub fn load_or_init(path: &Path) -> Keymap {
if path.exists() {
match Keymap::load(path) {
Ok(km) => km,
Err(e) => {
eprintln!(
"mirada · keymap «{}» inválido ({e}); uso el de por defecto.",
path.display()
);
Keymap::default()
}
}
} else {
let km = Keymap::default();
match km.save(path) {
Ok(()) => eprintln!("mirada · keymap inicial escrito en {}", path.display()),
Err(e) => eprintln!("mirada · no pude escribir el keymap inicial: {e}"),
}
km
}
}
/// Vigila el archivo del keymap para recargarlo en caliente.
pub fn watch(path: &Path) -> notify::Result<KeymapWatch> {
use notify::{RecursiveMode, Watcher};
let target = path.to_path_buf();
let (tx, rx) = mpsc::channel();
let mut watcher = notify::recommended_watcher(move |res: notify::Result<notify::Event>| {
if let Ok(event) = res {
// Vigilamos el directorio (los editores reescriben el
// archivo por *rename*); filtramos a nuestro archivo.
if event.paths.iter().any(|p| p == &target) {
let _ = tx.send(());
}
}
})?;
let dir = path.parent().filter(|d| d.exists());
watcher.watch(dir.unwrap_or(path), RecursiveMode::NonRecursive)?;
Ok(KeymapWatch { _watcher: watcher, rx })
}
}
/// Vigía del archivo de keymap para la recarga en caliente.
///
/// Mantenlo vivo mientras quieras recargas; al soltarlo, la vigilancia
/// cesa. Consulta [`changed`](KeymapWatch::changed) en tu bucle de eventos.
pub struct KeymapWatch {
_watcher: notify::RecommendedWatcher,
rx: mpsc::Receiver<()>,
}
impl KeymapWatch {
/// `true` si el archivo cambió desde la última consulta. Coalesce una
/// ráfaga de eventos (un guardado dispara varios) en un solo `true`.
pub fn changed(&self) -> bool {
self.rx.try_iter().count() > 0
}
}
/// La forma en disco del keymap — un mapa de cadenas. Las acciones van
/// como texto (`"layout:grid"`) y no como enum, para que el RON sea
/// trivial y los errores se reporten atajo a atajo.
#[derive(Serialize, Deserialize)]
struct KeymapFile {
bindings: BTreeMap<String, String>,
}
/// La cabecera de comentarios del archivo que escribe [`Keymap::save`].
const KEYMAP_HEADER: &str = "\
// keymap de mirada — atajos del escritorio (carmen).
//
// Formato: \"Combinación\": \"acción\"
// La combinación la canoniza el compositor: Super, Ctrl, Shift, Alt y la
// tecla, en ese orden (p. ej. \"Super+Shift+j\", \"Super+space\").
//
// Acciones:
// focus-next / focus-prev mueve el foco
// move-forward / move-backward reordena la ventana enfocada
// close-focused cierra la enfocada
// cycle-layout siguiente modo de teselado
// layout:master-stack | layout:monocle | layout:grid | layout:columns
// workspace:N activa el escritorio N (1..9)
// send-to-workspace:N manda la enfocada al escritorio N
// quit apaga el compositor
//
// Edita y guarda: mirada recarga el keymap en caliente, sin reiniciar.";
/// Un fallo al cargar o guardar un keymap.
#[derive(Debug)]
pub enum KeymapError {
/// El RON no parsea, o una acción no se reconoce. El mensaje ya está
/// formateado para mostrarse al usuario.
Parse(String),
/// Fallo de E/S al leer o escribir el archivo.
Io(io::Error),
}
impl fmt::Display for KeymapError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
KeymapError::Parse(msg) => f.write_str(msg),
KeymapError::Io(e) => write!(f, "E/S: {e}"),
}
}
}
impl std::error::Error for KeymapError {}
impl From<io::Error> for KeymapError {
fn from(e: io::Error) -> Self {
KeymapError::Io(e)
}
}
#[cfg(test)]
mod tests {
use super::*;
use mirada_layout::LayoutMode;
#[test]
fn the_default_keymap_round_trips_through_ron() {
let km = Keymap::default();
let back = Keymap::from_ron(&km.to_ron()).unwrap();
assert_eq!(km, back);
}
#[test]
fn the_saved_file_carries_the_documentation_header() {
let km = Keymap::default();
let written = km.documented_ron();
// La cabecera son comentarios — RON los ignora al reparsear.
assert!(written.starts_with("// keymap de mirada"));
assert_eq!(Keymap::from_ron(&written).unwrap(), km);
}
#[test]
fn grab_list_is_exactly_the_set_of_bound_combos() {
let km = Keymap::default();
let grabs = km.grab_list();
assert_eq!(grabs.len(), km.len());
assert!(grabs.contains(&"Super+j".to_string()));
assert!(grabs.contains(&"Super+Shift+e".to_string()));
}
#[test]
fn lookup_resolves_a_default_binding() {
let km = Keymap::default();
assert_eq!(km.lookup("Super+q"), Some(DesktopAction::CloseFocused));
assert_eq!(km.lookup("Super+t"), Some(DesktopAction::SetLayout(LayoutMode::MasterStack)));
assert_eq!(km.lookup("Super+sin-asignar"), None);
}
#[test]
fn a_custom_keymap_parses_from_ron() {
let ron = r#"(
bindings: {
"Alt+Return": "cycle-layout",
"Alt+x": "close-focused",
"Alt+3": "workspace:3",
},
)"#;
let km = Keymap::from_ron(ron).unwrap();
assert_eq!(km.len(), 3);
assert_eq!(km.lookup("Alt+Return"), Some(DesktopAction::CycleLayout));
assert_eq!(km.lookup("Alt+3"), Some(DesktopAction::SwitchWorkspace(2)));
}
#[test]
fn an_unknown_action_names_the_offending_binding() {
let ron = r#"( bindings: { "Super+z": "fly-away" } )"#;
let err = Keymap::from_ron(ron).unwrap_err().to_string();
assert!(err.contains("Super+z"), "el error debe nombrar el atajo: {err}");
}
#[test]
fn malformed_ron_is_rejected() {
assert!(Keymap::from_ron("esto no es ron").is_err());
}
}
crates/modules/mirada/mirada-brain/src/lib.rs
+3
View File
@@ -12,14 +12,17 @@
//!
//! - [`action`] — las acciones de escritorio y el mapa de teclas.
//! - [`desktop`] — el [`Desktop`]: el estado y el bucle `evento → comandos`.
//! - [`keymap`] — el [`Keymap`] configurable en RON, recargable en caliente.
#![forbid(unsafe_code)]
pub mod action;
pub mod desktop;
pub mod keymap;
pub use action::{default_keymap, DesktopAction, WORKSPACE_COUNT};
pub use desktop::{Desktop, WindowInfo};
pub use keymap::{Keymap, KeymapError, KeymapWatch};
pub use mirada_layout::{LayoutMode, LayoutParams, Rect, WindowId, Workspace};
pub use mirada_protocol::{BodyEvent, BrainCommand, OutputId, WindowPlacement};
vamos.txt
+10
View File
@@ -1002,5 +1002,15 @@
Atajos de teclado configurables — mirada-brain::Keymap:
El keymap vive sólo en el Cerebro; el Cuerpo nunca lo ve (sólo recibe la lista de cadenas a interceptar, GrabKeys).
Disco: RON de texto en ~/.config/mirada/keymap.ron — editable a mano, versionable, recargado en caliente (notify).
Si falta, la app escribe uno por defecto documentado; si está corrupto, avisa y usa el de por defecto sin pisarlo.
cargo run -p mirada-brain --example keymap-default # imprime el keymap por defecto en RON
Acciones como cadena estable: "focus-next", "layout:grid", "workspace:3" (DesktopAction: Display + FromStr).
Sin ejecutable configurador: el editor de texto del usuario, y la app mirada sobre el mismo API Keymap.