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

feat(mirada): 3 layouts nuevos + redimensionar el área maestra

Browse Source 
mirada-layout pasa de 4 a 7 modos de teselado, todos intercambiables
por el API (SetLayout / CycleLayout / mirada-ctl layout <modo>):

- Rows: filas horizontales de igual alto (complemento de Columns).
- Spiral: espiral de Fibonacci — cada ventana parte por la mitad el
  espacio restante, alternando el sentido del corte.
- CenteredMaster: maestra centrada + pila a ambos lados (monitores
  anchos).

LayoutMode::ALL + next() definen el ciclo. Añade dos acciones,
GrowMaster/ShrinkMaster (Super+l / Super+h), que ajustan master_ratio
en caliente — ese parámetro existía pero no había forma de tocarlo.

Cableado completo: tile(), cycle, slugs Display/FromStr, keymap por
defecto (Super+r/d/s), HUD de mirada, mirada-ctl actions. El ejemplo
headless-ctl ahora imprime la geometría para verificar los layouts.

mirada-layout 22->26 tests, mirada-brain 37->39.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
sergio
2026-05-21 00:37:16 +00:00
parent b31f988833
commit 8821d34bd5
10 changed files with 293 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/modules/mirada/SDD.md
+10 -4
View File
@@ -49,8 +49,10 @@ ejecuta operaciones de geometría".
## Detalle por crate
- **`mirada-layout`** — `Rect` + `split` (reparto exacto de píxeles),
`LayoutMode` (`MasterStack`/`Monocle`/`Grid`/`Columns`), `Workspace`
con foco cíclico y reordenado. Determinista.
`LayoutMode` con 7 modos (`MasterStack`, `CenteredMaster`, `Spiral`
—espiral de Fibonacci—, `Grid`, `Columns`, `Rows`, `Monocle`) y
`LayoutMode::next()` para el ciclo, `Workspace` con foco cíclico y
reordenado. Determinista.
- **`mirada-protocol`** — `WindowPlacement`, los enums `BrainCommand` y
`BodyEvent`, el marco `postcard` con prefijo `u32` LE
(`write_frame`/`read_frame`, guard `MAX_FRAME`) y el puente
@@ -109,6 +111,10 @@ que un front-end (`Keybind` → `lookup` → `apply`); hay otros tres:
- **`DesktopAction::FocusWindow(WindowId)`** — direccionamiento directo de
una ventana (no sólo ciclar con `FocusNext`/`Prev`); si está en otro
escritorio, salta a él. Lo usan la taskbar y `mirada-ctl`.
- **`SetLayout`/`CycleLayout`/`GrowMaster`/`ShrinkMaster`** — los 7 modos
de teselado se intercambian por el API (`mirada-ctl layout spiral`), y
el área maestra se redimensiona en caliente (`grow`/`shrink-master`,
atajos `Super+l`/`Super+h`).
- **HUD interactivo** (app `mirada`) — los pips de escritorio y las
ventanas del lienzo son clicables: clic = `apply` de la acción.
- **`mirada-ctl`** — control externo por línea de comandos
@@ -130,8 +136,8 @@ gráficos para ejercitar `mirada-ctl` en modo desatendido.
## Estado
Implementado y verde: `mirada-layout` (22 tests), `mirada-protocol`
(9), `mirada-brain` (37), `mirada-link` (7), `mirada-body` (13), las
Implementado y verde: `mirada-layout` (26 tests), `mirada-protocol`
(9), `mirada-brain` (39), `mirada-link` (7), `mirada-body` (13), las
apps `mirada` y `mirada-compositor` (compilan; verificación visual
manual) y `mirada-ctl` (CLI, probado vía el ejemplo `headless-ctl`).
crates/modules/mirada/mirada-brain/examples/headless-ctl.rs
+29 -11
View File
@@ -27,7 +27,7 @@ fn main() {
std::process::exit(1);
}
};
println!("Cerebro headless · control en {}", path.display());
eprintln!("Cerebro headless · control en {}", path.display());
// Una pantalla y tres ventanas de muestra.
let mut desktop = Desktop::new();
@@ -40,21 +40,37 @@ fn main() {
});
}
print_state(&desktop);
println!(" esperando a mirada-ctl …");
eprintln!(" esperando a mirada-ctl …");
loop {
if let Some(mut conn) = server.poll() {
if let Ok(Some(req)) = conn.read_request() {
let reply = match req {
CtlRequest::Do(action) => {
let cmds = desktop.apply(action);
// Sin Cuerpo: simulamos nosotros el cierre.
for cmd in cmds {
if let BrainCommand::Close(id) | BrainCommand::Kill(id) = cmd {
desktop.on_event(BodyEvent::WindowClosed { id });
eprintln!("· {action}");
for cmd in desktop.apply(action) {
match cmd {
// La geometría que el Cerebro mandaría al Cuerpo.
BrainCommand::Place(places) => {
for p in places {
eprintln!(
" win {} → {:>5}×{:<4} @ ({:>5},{:>4}){}",
p.id,
p.rect.w,
p.rect.h,
p.rect.x,
p.rect.y,
if p.focused { " *" } else { "" },
);
}
}
// Sin Cuerpo: simulamos nosotros el cierre.
BrainCommand::Close(id) | BrainCommand::Kill(id) => {
desktop.on_event(BodyEvent::WindowClosed { id });
}
_ => {}
}
}
println!("· {action}");
print_state(&desktop);
CtlReply::Ok
}
@@ -68,10 +84,12 @@ fn main() {
}
fn print_state(d: &Desktop) {
println!(
" escritorio {} · foco {:?} · ventanas/escritorio {:?}",
let ws = d.active_workspace();
eprintln!(
" escritorio {} · {:?} (maestra {:.0}%) · foco {:?}",
d.active_index() + 1,
ws.params().mode,
ws.params().master_ratio * 100.0,
d.focused_window(),
d.workspace_loads(),
);
}
crates/modules/mirada/mirada-brain/src/action.rs
+20 -6
View File
@@ -42,6 +42,10 @@ pub enum DesktopAction {
CycleLayout,
/// Fija un modo de teselado concreto.
SetLayout(LayoutMode),
/// Agranda el área de la ventana maestra (`MasterStack`/`CenteredMaster`).
GrowMaster,
/// Encoge el área de la ventana maestra.
ShrinkMaster,
/// Activa el escritorio virtual `n` (índice 0-based).
SwitchWorkspace(usize),
/// Manda la ventana enfocada al escritorio virtual `n`.
@@ -58,6 +62,9 @@ fn layout_slug(mode: LayoutMode) -> &'static str {
LayoutMode::Monocle => "monocle",
LayoutMode::Grid => "grid",
LayoutMode::Columns => "columns",
LayoutMode::Rows => "rows",
LayoutMode::CenteredMaster => "centered-master",
LayoutMode::Spiral => "spiral",
}
}
@@ -68,6 +75,9 @@ fn layout_from_slug(slug: &str) -> Option<LayoutMode> {
"monocle" => LayoutMode::Monocle,
"grid" => LayoutMode::Grid,
"columns" => LayoutMode::Columns,
"rows" => LayoutMode::Rows,
"centered-master" => LayoutMode::CenteredMaster,
"spiral" => LayoutMode::Spiral,
_ => return None,
})
}
@@ -84,6 +94,8 @@ impl fmt::Display for DesktopAction {
DesktopAction::CloseFocused => f.write_str("close-focused"),
DesktopAction::CycleLayout => f.write_str("cycle-layout"),
DesktopAction::SetLayout(m) => write!(f, "layout:{}", layout_slug(*m)),
DesktopAction::GrowMaster => f.write_str("grow-master"),
DesktopAction::ShrinkMaster => f.write_str("shrink-master"),
// 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),
@@ -105,6 +117,8 @@ impl FromStr for DesktopAction {
"move-backward" => Self::MoveBackward,
"close-focused" => Self::CloseFocused,
"cycle-layout" => Self::CycleLayout,
"grow-master" => Self::GrowMaster,
"shrink-master" => Self::ShrinkMaster,
"quit" => Self::Quit,
_ => {
if let Some(slug) = s.strip_prefix("layout:") {
@@ -162,6 +176,11 @@ pub fn default_keymap() -> Vec<(String, DesktopAction)> {
("Super+m".into(), DesktopAction::SetLayout(LayoutMode::Monocle)),
("Super+g".into(), DesktopAction::SetLayout(LayoutMode::Grid)),
("Super+c".into(), DesktopAction::SetLayout(LayoutMode::Columns)),
("Super+r".into(), DesktopAction::SetLayout(LayoutMode::Rows)),
("Super+d".into(), DesktopAction::SetLayout(LayoutMode::CenteredMaster)),
("Super+s".into(), DesktopAction::SetLayout(LayoutMode::Spiral)),
("Super+h".into(), DesktopAction::ShrinkMaster),
("Super+l".into(), DesktopAction::GrowMaster),
("Super+Shift+e".into(), DesktopAction::Quit),
];
// Un escritorio por dígito: `Super+1`..`Super+9` lo activan,
@@ -214,12 +233,7 @@ mod tests {
#[test]
fn every_layout_mode_round_trips() {
for mode in [
LayoutMode::MasterStack,
LayoutMode::Monocle,
LayoutMode::Grid,
LayoutMode::Columns,
] {
for mode in LayoutMode::ALL {
let a = DesktopAction::SetLayout(mode);
assert_eq!(a, a.to_string().parse().unwrap());
}
crates/modules/mirada/mirada-brain/src/desktop.rs
+46 -21
View File
@@ -2,7 +2,7 @@
use std::collections::HashMap;
use mirada_layout::{LayoutMode, LayoutParams, Rect, WindowId, Workspace};
use mirada_layout::{LayoutParams, Rect, WindowId, Workspace};
use mirada_protocol::{placements, BodyEvent, BrainCommand, OutputId};
use crate::action::{DesktopAction, WORKSPACE_COUNT};
@@ -180,7 +180,7 @@ impl Desktop {
}
}
DesktopAction::CycleLayout => {
let next = cycle_mode(self.workspaces[self.active].params().mode);
let next = self.workspaces[self.active].params().mode.next();
self.workspaces[self.active].set_mode(next);
self.relayout()
}
@@ -188,6 +188,8 @@ impl Desktop {
self.workspaces[self.active].set_mode(mode);
self.relayout()
}
DesktopAction::GrowMaster => self.nudge_master(0.05),
DesktopAction::ShrinkMaster => self.nudge_master(-0.05),
DesktopAction::SwitchWorkspace(n) => {
if n < self.workspaces.len() && n != self.active {
self.active = n;
@@ -213,6 +215,15 @@ impl Desktop {
}
}
/// Ajusta la fracción del área maestra del escritorio activo (la usan
/// `MasterStack` y `CenteredMaster`), acotada a `0.05..=0.95`.
fn nudge_master(&mut self, delta: f32) -> Vec<BrainCommand> {
let ws = &mut self.workspaces[self.active];
let ratio = (ws.params().master_ratio + delta).clamp(0.05, 0.95);
ws.set_master_ratio(ratio);
self.relayout()
}
/// Recalcula la geometría del escritorio activo y la empaqueta en un
/// [`BrainCommand::Place`]. Sin salida conectada, no hay nada que
/// colocar.
@@ -281,19 +292,10 @@ impl Desktop {
}
}
/// El siguiente modo en el ciclo de [`DesktopAction::CycleLayout`].
fn cycle_mode(mode: LayoutMode) -> LayoutMode {
match mode {
LayoutMode::MasterStack => LayoutMode::Monocle,
LayoutMode::Monocle => LayoutMode::Grid,
LayoutMode::Grid => LayoutMode::Columns,
LayoutMode::Columns => LayoutMode::MasterStack,
}
}
#[cfg(test)]
mod tests {
use super::*;
use mirada_layout::LayoutMode;
/// Un escritorio con una salida 1920×1080 ya conectada.
fn desktop_with_screen() -> Desktop {
@@ -442,19 +444,42 @@ mod tests {
}
#[test]
fn cycle_layout_walks_the_four_modes() {
fn cycle_layout_walks_every_mode_and_returns() {
let mut d = desktop_with_screen();
open(&mut d, 1);
assert_eq!(d.active_workspace().params().mode, LayoutMode::MasterStack);
for expected in [
LayoutMode::Monocle,
LayoutMode::Grid,
LayoutMode::Columns,
LayoutMode::MasterStack,
] {
let start = d.active_workspace().params().mode;
for _ in 0..LayoutMode::ALL.len() {
let before = d.active_workspace().params().mode;
d.on_event(BodyEvent::Keybind("Super+space".into()));
assert_eq!(d.active_workspace().params().mode, expected);
assert_eq!(d.active_workspace().params().mode, before.next());
}
// Una vuelta completa devuelve al modo inicial.
assert_eq!(d.active_workspace().params().mode, start);
}
#[test]
fn grow_and_shrink_master_adjust_the_ratio() {
let mut d = desktop_with_screen();
open(&mut d, 1);
let r0 = d.active_workspace().params().master_ratio;
d.apply(DesktopAction::GrowMaster);
assert!(d.active_workspace().params().master_ratio > r0);
d.apply(DesktopAction::ShrinkMaster);
assert!((d.active_workspace().params().master_ratio - r0).abs() < 1e-6);
}
#[test]
fn master_ratio_stays_within_bounds() {
let mut d = desktop_with_screen();
open(&mut d, 1);
for _ in 0..50 {
d.apply(DesktopAction::GrowMaster);
}
assert!(d.active_workspace().params().master_ratio <= 0.95);
for _ in 0..50 {
d.apply(DesktopAction::ShrinkMaster);
}
assert!(d.active_workspace().params().master_ratio >= 0.05);
}
#[test]
crates/modules/mirada/mirada-brain/src/keymap.rs
+3 -1
View File
@@ -238,7 +238,9 @@ const KEYMAP_HEADER: &str = "\
// 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
// layout:<modo> master-stack | centered-master | spiral
// grid | columns | rows | monocle
// grow-master / shrink-master redimensiona el área maestra
// workspace:N activa el escritorio N (1..9)
// send-to-workspace:N manda la enfocada al escritorio N
// quit apaga el compositor
crates/modules/mirada/mirada-layout/src/layout.rs
+140 -7
View File
@@ -5,6 +5,9 @@ use serde::{Deserialize, Serialize};
use crate::geometry::{split, Rect};
/// Estrategia de teselado.
///
/// Las variantes nuevas se añaden **al final** para no mover los índices
/// con que `postcard` las serializa en el API de control.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum LayoutMode {
@@ -16,6 +19,33 @@ pub enum LayoutMode {
Grid,
/// Columnas verticales de igual ancho.
Columns,
/// Filas horizontales de igual alto.
Rows,
/// Ventana maestra centrada; el resto en columnas a ambos lados.
/// Pensado para monitores anchos.
CenteredMaster,
/// Espiral de Fibonacci: cada ventana parte por la mitad el espacio
/// que queda, alternando el sentido del corte.
Spiral,
}
impl LayoutMode {
/// Todos los modos, en el orden del ciclo de `CycleLayout`.
pub const ALL: [LayoutMode; 7] = [
LayoutMode::MasterStack,
LayoutMode::CenteredMaster,
LayoutMode::Spiral,
LayoutMode::Grid,
LayoutMode::Columns,
LayoutMode::Rows,
LayoutMode::Monocle,
];
/// El siguiente modo en el ciclo (envuelve al llegar al final).
pub fn next(self) -> LayoutMode {
let i = Self::ALL.iter().position(|&m| m == self).unwrap_or(0);
Self::ALL[(i + 1) % Self::ALL.len()]
}
}
/// Parámetros del teselado.
@@ -45,8 +75,11 @@ pub fn tile(screen: Rect, count: usize, params: &LayoutParams) -> Vec<Rect> {
let cells = match params.mode {
LayoutMode::Monocle => vec![screen; count],
LayoutMode::Columns => columns(screen, count),
LayoutMode::Rows => rows(screen, count),
LayoutMode::Grid => grid(screen, count),
LayoutMode::MasterStack => master_stack(screen, count, params.master_ratio),
LayoutMode::CenteredMaster => centered_master(screen, count, params.master_ratio),
LayoutMode::Spiral => spiral(screen, count),
};
// El margen se aplica al final, uniforme para todos los modos.
cells.into_iter().map(|c| c.inset(params.gap)).collect()
@@ -75,6 +108,65 @@ fn grid(screen: Rect, count: usize) -> Vec<Rect> {
.collect()
}
/// Filas horizontales de igual alto.
fn rows(screen: Rect, count: usize) -> Vec<Rect> {
split(screen.h, count)
.into_iter()
.map(|(off, h)| Rect::new(screen.x, screen.y + off, screen.w, h))
.collect()
}
/// Espiral de Fibonacci: cada ventana se queda con la mitad del espacio
/// libre y la siguiente recurre en la otra mitad, alternando el corte.
/// La última ventana llena todo lo que sobra.
fn spiral(screen: Rect, count: usize) -> Vec<Rect> {
let mut out = Vec::with_capacity(count);
let mut area = screen;
let mut horizontal = true;
for _ in 1..count {
if horizontal {
let p = split(area.w, 2);
out.push(Rect::new(area.x, area.y, p[0].1, area.h));
area = Rect::new(area.x + p[1].0, area.y, p[1].1, area.h);
} else {
let p = split(area.h, 2);
out.push(Rect::new(area.x, area.y, area.w, p[0].1));
area = Rect::new(area.x, area.y + p[1].0, area.w, p[1].1);
}
horizontal = !horizontal;
}
out.push(area);
out
}
/// Ventana maestra centrada + pila repartida en columnas a ambos lados.
fn centered_master(screen: Rect, count: usize, ratio: f32) -> Vec<Rect> {
// Con una o dos ventanas no hay nada que centrar: cae a maestro+pila.
if count <= 2 {
return master_stack(screen, count, ratio);
}
let ratio = ratio.clamp(0.05, 0.95);
let master_w = (screen.w as f32 * ratio).round() as i32;
let sides = split(screen.w - master_w, 2);
let (left_w, right_w) = (sides[0].1, sides[1].1);
let stack = count - 1;
let left_n = stack / 2;
let right_n = stack - left_n;
let mut out = Vec::with_capacity(count);
// 0 = la maestra, centrada.
out.push(Rect::new(screen.x + left_w, screen.y, master_w, screen.h));
// Columna izquierda, luego la derecha — el orden de teselado.
for (off, h) in split(screen.h, left_n) {
out.push(Rect::new(screen.x, screen.y + off, left_w, h));
}
for (off, h) in split(screen.h, right_n) {
out.push(Rect::new(screen.x + left_w + master_w, screen.y + off, right_w, h));
}
out
}
/// Ventana maestra a la izquierda + pila a la derecha.
fn master_stack(screen: Rect, count: usize, ratio: f32) -> Vec<Rect> {
if count == 1 {
@@ -110,18 +202,59 @@ mod tests {
#[test]
fn tile_count_matches_window_count() {
for mode in [
LayoutMode::MasterStack,
LayoutMode::Monocle,
LayoutMode::Grid,
LayoutMode::Columns,
] {
for mode in LayoutMode::ALL {
for n in 1..=9 {
assert_eq!(tile(SCREEN, n, &params(mode)).len(), n);
assert_eq!(tile(SCREEN, n, &params(mode)).len(), n, "modo {mode:?}");
}
}
}
#[test]
fn rows_partition_the_height_exactly() {
let rects = tile(SCREEN, 3, &params(LayoutMode::Rows));
assert_eq!(rects.iter().map(|r| r.h).sum::<i32>(), 1080);
assert!(rects.iter().all(|r| r.w == 1920));
}
#[test]
fn spiral_tiles_cover_the_screen_without_overlap() {
for n in 1..=9 {
let total: i64 = tile(SCREEN, n, &params(LayoutMode::Spiral))
.iter()
.map(|r| r.area())
.sum();
assert_eq!(total, SCREEN.area(), "espiral con {n} ventanas");
}
}
#[test]
fn centered_master_centers_the_master_and_covers_the_screen() {
let rects = tile(SCREEN, 5, &params(LayoutMode::CenteredMaster));
let master = rects[0];
// Hueco a la izquierda y a la derecha de la maestra: iguales ±1px.
let left = master.x - SCREEN.x;
let right = (SCREEN.x + SCREEN.w) - (master.x + master.w);
assert!((left - right).abs() <= 1, "maestra no centrada: {left} vs {right}");
let total: i64 = rects.iter().map(|r| r.area()).sum();
assert_eq!(total, SCREEN.area());
}
#[test]
fn layout_mode_next_cycles_through_every_mode() {
let mut visited: Vec<LayoutMode> = Vec::new();
let mut m = LayoutMode::MasterStack;
for _ in 0..LayoutMode::ALL.len() {
assert!(!visited.contains(&m), "modo repetido en el ciclo: {m:?}");
visited.push(m);
m = m.next();
}
// Tras una vuelta completa, de vuelta al inicio.
assert_eq!(m, LayoutMode::MasterStack);
for mode in LayoutMode::ALL {
assert!(visited.contains(&mode), "el ciclo no pasa por {mode:?}");
}
}
#[test]
fn monocle_gives_every_window_the_full_screen() {
for r in tile(SCREEN, 4, &params(LayoutMode::Monocle)) {