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

feat(mirada): acople del shell — ventana-dock al pie de la pantalla

Browse Source 
Fase 2 del plan «shell»: carmen reconoce la ventana del shell y le
reserva su sitio, en vez de teselarla como una más.

Una ventana cuyo `app_id` es `carmen.shell` no entra en el teselado:
carmen le reserva una franja de 40 px al pie de la salida, la dimensiona
y la fija ahí, y la compone sobre todas las demás. El Cerebro tesela el
resto de ventanas en el área que queda.

- `mirada-protocol`: nuevo `BodyEvent::OutputResized { id, w, h }` — el
  Cerebro cambia el área útil de una salida **sin** perder el escritorio
  que muestra (a diferencia de quitar y volver a añadir la salida — que,
  de paso, era un bug latente al redimensionar la ventana winit).
- `mirada-brain`: `Desktop` atiende `OutputResized` (test nuevo).
- `mirada-body`: `BodyState::resize_output`.
- `mirada-compositor`: `ManagedWindow.is_shell`, `App.output_size`,
  `dock_shell`/`output_changed`; `register_toplevel` no registra el
  shell en el Cerebro; al cerrarse libera la franja. El shell se compone
  y se enfoca con el ratón aunque no viva en el Cerebro; no lleva marco.
  El backend winit usa ahora `resize_output` al redimensionar.

GPUI no habla `wlr-layer-shell`, así que el acople es por `app_id`.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
sergio
2026-05-21 05:38:12 +00:00
parent 7b5c583a98
commit ee27108f6c
7 changed files with 178 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/apps/mirada-compositor/src/drm_backend.rs
+43 -20
View File
@@ -157,8 +157,8 @@ impl DrmState {
// tamaño (sigue al contenido) y su color (según el foco). Cada
// `SolidColorBuffer` sube su contador de daño sólo si algo cambió.
for w in &mut self.app.windows {
if !w.visible {
continue;
if !w.visible || w.is_shell {
continue; // el shell no lleva marco
}
let (x, y) = crate::render_loc(w);
let (sw, sh) = crate::surface_px_size(w).unwrap_or(w.size);
@@ -210,21 +210,27 @@ impl DrmState {
}
}
// El shell va sobre todo; luego las flotantes; luego las
// teseladas. `sort_by_key` es estable: respeta el orden de
// apertura dentro de cada grupo.
let mut shown: Vec<_> = self.app.windows.iter().filter(|w| w.visible).collect();
shown.sort_by_key(|w| !w.floating);
shown.sort_by_key(|w| (!w.is_shell, !w.floating));
for w in &shown {
let (x, y) = crate::render_loc(w);
let (sw, sh) = crate::surface_px_size(w).unwrap_or(w.size);
let rects = border_rects(x, y, sw, sh);
// El marco, encima de la propia superficie de la ventana.
for (buf, (bx, by, _, _)) in w.borders.iter().zip(rects) {
out.push(Frame::Solid(SolidColorRenderElement::from_buffer(
buf,
(bx, by),
1.0,
1.0,
Kind::Unspecified,
)));
// El marco, encima de la propia superficie de la ventana
// — el shell no lleva.
if !w.is_shell {
let rects = border_rects(x, y, sw, sh);
for (buf, (bx, by, _, _)) in w.borders.iter().zip(rects) {
out.push(Frame::Solid(SolidColorRenderElement::from_buffer(
buf,
(bx, by),
1.0,
1.0,
Kind::Unspecified,
)));
}
}
for el in render_elements_from_surface_tree(
&mut self.renderer,
@@ -525,13 +531,25 @@ impl DrmState {
self.app.cursor_status = CursorImageStatus::default_named();
}
// Foco-sigue-ratón: al pasar a otra ventana, que el Cerebro la enfoque.
// Foco-sigue-ratón: al pasar a otra ventana, que la enfoque quien
// corresponda — el Cerebro para las teseladas, carmen mismo para
// el shell (que no vive en el Cerebro).
let hovered = hit.map(|i| self.app.windows[i].id);
if hovered != self.last_pointer_window {
self.last_pointer_window = hovered;
if let Some(id) = hovered {
let ev = self.app.body.pointer_enter(id);
self.app.brain_feed(ev);
match hit {
Some(i) if self.app.windows[i].is_shell => {
let surf = self.app.windows[i].surface.clone();
if let Some(kb) = self.app.keyboard.clone() {
kb.set_focus(&mut self.app, Some(surf), SERIAL_COUNTER.next_serial());
}
}
Some(i) => {
let id = self.app.windows[i].id;
let ev = self.app.body.pointer_enter(id);
self.app.brain_feed(ev);
}
None => {}
}
}
}
@@ -564,13 +582,17 @@ impl DrmState {
true
}
/// El índice de la ventana visible bajo el punto `(x, y)`, si la hay —
/// en orden front-to-back (las flotantes ganan a las teseladas).
/// El índice de la ventana visible bajo el punto `(x, y)`, si la hay
/// — en orden front-to-back (el shell gana a las flotantes, y éstas a
/// las teseladas).
fn window_at(&self, x: f64, y: f64) -> Option<usize> {
let mut idx: Vec<usize> = (0..self.app.windows.len())
.filter(|&i| self.app.windows[i].visible)
.collect();
idx.sort_by_key(|&i| !self.app.windows[i].floating);
idx.sort_by_key(|&i| {
let w = &self.app.windows[i];
(!w.is_shell, !w.floating)
});
idx.into_iter().find(|&i| {
let w = &self.app.windows[i];
let (lx, ly) = crate::render_loc(w);
@@ -716,6 +738,7 @@ pub fn run() -> Result<(), Box<dyn Error>> {
// La salida del Cerebro = el modo del monitor.
let ev = app.body.add_output(0, mode_w as i32, mode_h as i32);
app.brain_feed(ev);
app.output_size = (mode_w as i32, mode_h as i32);
// El puntero arranca en el centro de la pantalla.
app.pointer_loc = (mode_w as f64 / 2.0, mode_h as f64 / 2.0);
// Anuncia el monitor en el protocolo Wayland — los clientes lo exigen.
crates/apps/mirada-compositor/src/main.rs
+77 -13
View File
@@ -89,6 +89,13 @@ enum Brain {
Linked(BodyLink),
}
/// `app_id` que distingue a la ventana del shell del escritorio. carmen
/// no la tesela: la acopla a una franja al pie de la pantalla.
const SHELL_APP_ID: &str = "carmen.shell";
/// Alto en píxeles de la franja del shell, al pie de la salida.
const SHELL_DOCK_HEIGHT: i32 = 40;
/// Una ventana de cliente que el compositor gestiona.
struct ManagedWindow {
id: u64,
@@ -104,6 +111,8 @@ struct ManagedWindow {
floating: bool,
/// `true` si tiene el foco del teclado — pinta el marco resaltado.
focused: bool,
/// `true` si es la ventana del shell — acoplada al pie, sin teselar.
is_shell: bool,
/// Búferes de los 4 lados del marco (arriba, abajo, izq., der.) —
/// cada uno con su `Id` estable para el seguimiento de daño.
borders: [SolidColorBuffer; 4],
@@ -150,6 +159,9 @@ struct App {
cursor_status: CursorImageStatus,
/// Arrastre de ventana en curso (mover o redimensionar con el ratón).
drag: Option<DragGrab>,
/// Tamaño real de la salida (con la franja del shell incluida) — lo
/// fija el backend; sirve para acoplar la ventana del shell.
output_size: (i32, i32),
/// Ventanas gestionadas, en orden de aparición.
windows: Vec<ManagedWindow>,
@@ -304,8 +316,8 @@ impl App {
})
.unwrap_or_default()
});
let app_id = if app_id.is_empty() { "cliente".into() } else { app_id };
let title = if title.is_empty() { format!("ventana {id}") } else { title };
// La ventana del shell no se tesela: carmen la acopla al pie.
let is_shell = app_id == SHELL_APP_ID;
self.windows.push(ManagedWindow {
id,
@@ -316,10 +328,55 @@ impl App {
visible: false,
floating: false,
focused: false,
is_shell,
borders: std::array::from_fn(|_| SolidColorBuffer::default()),
});
let ev = self.body.open_surface(id, app_id, title);
if is_shell {
self.dock_shell();
} else {
let app_id = if app_id.is_empty() { "cliente".into() } else { app_id };
let title = if title.is_empty() { format!("ventana {id}") } else { title };
let ev = self.body.open_surface(id, app_id, title);
self.brain_feed(ev);
}
}
/// Acopla la ventana del shell: le reserva una franja al pie de la
/// salida —el Cerebro tesela el área que queda— y la dimensiona y
/// coloca ahí. Se llama al registrarla y al cambiar el tamaño de la
/// salida.
fn dock_shell(&mut self) {
let (ow, oh) = self.output_size;
if ow == 0 || oh == 0 {
return; // la salida todavía no está lista
}
// Reserva la franja: el Cerebro tesela en el alto que queda.
let ev = self.body.resize_output(0, ow, oh - SHELL_DOCK_HEIGHT);
self.brain_feed(ev);
// Dimensiona la ventana del shell y la fija en la franja.
if let Some(w) = self.windows.iter_mut().find(|w| w.is_shell) {
w.loc = (0, oh - SHELL_DOCK_HEIGHT);
w.size = (ow, SHELL_DOCK_HEIGHT);
w.visible = true;
w.toplevel.with_pending_state(|s| {
s.size = Some((ow.max(1), SHELL_DOCK_HEIGHT.max(1)).into());
});
w.toplevel.send_pending_configure();
}
}
/// El backend informa de un tamaño de salida nuevo (arranque o
/// redimensión). Si hay shell acoplado, recoloca su franja; si no,
/// le pasa el área entera al Cerebro.
fn output_changed(&mut self, width: i32, height: i32) {
self.output_size = (width, height);
if self.windows.iter().any(|w| w.is_shell) {
self.dock_shell();
} else {
let ev = self.body.resize_output(0, width, height);
self.brain_feed(ev);
}
}
}
@@ -388,8 +445,16 @@ impl XdgShellHandler for App {
.iter()
.position(|w| w.surface == *surface.wl_surface());
if let Some(pos) = pos {
let id = self.windows.remove(pos).id;
if let Some(ev) = self.body.close_surface(id) {
let w = self.windows.remove(pos);
if w.is_shell {
// El shell se cerró: libera su franja, el Cerebro vuelve
// a teselar en la salida entera.
let (ow, oh) = self.output_size;
if ow != 0 && oh != 0 {
let ev = self.body.resize_output(0, ow, oh);
self.brain_feed(ev);
}
} else if let Some(ev) = self.body.close_surface(w.id) {
self.brain_feed(ev);
}
}
@@ -813,6 +878,7 @@ fn build_app() -> Result<Setup, Box<dyn std::error::Error>> {
pointer_loc: (0.0, 0.0),
cursor_status: CursorImageStatus::default_named(),
drag: None,
output_size: (0, 0),
windows: Vec::new(),
body: BodyState::new(),
brain,
@@ -925,6 +991,7 @@ fn run_winit() -> Result<(), Box<dyn std::error::Error>> {
{
let ev = state.body.add_output(0, win_size.w, win_size.h);
state.brain_feed(ev);
state.output_size = (win_size.w, win_size.h);
}
while state.running {
@@ -932,10 +999,7 @@ fn run_winit() -> Result<(), Box<dyn std::error::Error>> {
let status = winit.dispatch_new_events(|event| match event {
WinitEvent::CloseRequested => state.running = false,
WinitEvent::Resized { size, .. } => {
let ev = state.body.remove_output(0);
state.brain_feed(ev);
let ev = state.body.add_output(0, size.w, size.h);
state.brain_feed(ev);
state.output_changed(size.w, size.h);
}
WinitEvent::Input(InputEvent::Keyboard { event }) => {
let code = event.key_code();
@@ -1015,12 +1079,12 @@ fn run_winit() -> Result<(), Box<dyn std::error::Error>> {
{
let (renderer, mut framebuffer) = backend.bind().unwrap();
// Orden de pintado: la lista de elementos va front-to-back
// (índice 0 = encima), así que las flotantes —que deben
// quedar sobre las teseladas— se ordenan primero. `sort_by_key`
// es estable: dentro de cada grupo se respeta el orden de apertura.
// (índice 0 = encima): el shell primero —va sobre todo—, luego
// las flotantes, luego las teseladas. `sort_by_key` es estable:
// dentro de cada grupo se respeta el orden de apertura.
let mut shown: Vec<&ManagedWindow> =
state.windows.iter().filter(|w| w.visible).collect();
shown.sort_by_key(|w| !w.floating);
shown.sort_by_key(|w| (!w.is_shell, !w.floating));
let elements: Vec<WaylandSurfaceRenderElement<GlesRenderer>> = shown
.iter()
.flat_map(|w| {