tawasuyu/llimphi

1//! Volcado headless del renderizador `allichay` a PNG: monta `allichay_view`
2//! sobre el schema REAL de mirada, computa el layout, lo pinta a una
3//! `vello::Scene` y lee la textura (GPU llvmpipe). Sirve para VER el panel sin
4//! levantar ventana.
5//!
6//! `cargo run -p llimphi-module-allichay --example dump_panel -- [out.png] [seccion]`
7//! (seccion = índice de diente; 1 = Decoración, rica en sliders + colores)
8
9use std::fs::File;
10use std::io::BufWriter;
11
12use allichay::{Configurable, Field, Schema, Section};
13use llimphi_module_allichay::{schema_panel, settings_overlay, AllichayMsg, AllichayState};
14use llimphi_widget_dock_rail::{dock_rail_view, DockRailItem, DockRailPalette};
15use llimphi_ui::llimphi_text::Alignment;
16
17use llimphi_ui::llimphi_compositor::{measure_text_node, mount, paint};
18use llimphi_ui::llimphi_hal::{wgpu, Hal};
19use llimphi_ui::llimphi_layout::taffy;
20use llimphi_ui::llimphi_layout::taffy::prelude::{
21    auto, length, percent, FlexDirection, Position, Size, Style,
22};
23use llimphi_ui::llimphi_layout::taffy::{AlignItems, Rect};
24use llimphi_ui::llimphi_layout::LayoutTree;
25use llimphi_ui::llimphi_raster::peniko::Color;
26use llimphi_ui::llimphi_raster::{vello, Renderer};
27use llimphi_ui::llimphi_text::Typesetter;
28use llimphi_ui::View;
29
30const W: u32 = 960;
31const H: u32 = 620;
32const FMT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
33
34fn prefix(mut s: Schema, target: &str) -> Schema {
35    for sec in &mut s.sections {
36        sec.id = format!("{target}::{}", sec.id);
37    }
38    s
39}
40
41fn main() {
42    let out = std::env::args().nth(1).unwrap_or_else(|| "allichay.png".to_string());
43    let sel: usize = std::env::args().nth(2).and_then(|s| s.parse().ok()).unwrap_or(1);
44
45    let theme = llimphi_theme::Theme::default();
46
47    // Rail de pestañas representativo del panel: la categoría Sistema (varios
48    // items) + dos apps. Aprovecha la triple jerarquía (sin paneles de 1 item).
49    let eo = allichay::EnumOption::new;
50    let sistema = Schema::new()
51        .section(
52            Section::new("wawa::apariencia", "Apariencia")
53                .icon("🎨")
54                .field(Field::toggle("oscuro", "Modo oscuro", true))
55                .field(Field::dropdown("acento", "Acento", "tawasuyu", vec![eo("tawasuyu", "tawasuyu"), eo("yachay", "yachay")])),
56        )
57        .section(
58            Section::new("wawa::idioma", "Idioma")
59                .icon("🌐")
60                .field(Field::dropdown("lang", "Idioma", "es-PE", vec![eo("es-PE", "Español"), eo("en-US", "English")])),
61        )
62        .section(
63            Section::new("wawa::interfaz", "Interfaz")
64                .icon("🎛")
65                .field(Field::display("toolkit", "Toolkit", "llimphi")),
66        )
67        .section(
68            Section::new("wawa::arranque", "Arranque")
69                .icon("▶")
70                .field(Field::display("init", "Init", "systemd (actual)")),
71        )
72        .section(
73            Section::new("wawa::modulos", "Módulos")
74                .icon("☸")
75                .field(Field::toggle("mirada", "mirada", true))
76                .field(Field::toggle("shuma", "shuma", true)),
77        );
78    // Mirada con un par de entradas de menú, para que la tabla del menú raíz se
79    // vea poblada (el default trae el menú vacío).
80    let mut mirada_cfg = mirada_brain::Config::default();
81    mirada_cfg.menu = vec![
82        mirada_brain::MenuEntry {
83            label: "Editor".into(),
84            command: "nada".into(),
85            submenu: Vec::new(),
86        },
87        mirada_brain::MenuEntry {
88            label: "Terminal".into(),
89            command: "alacritty".into(),
90            submenu: Vec::new(),
91        },
92    ];
93    mirada_cfg.outputs = vec![mirada_brain::OutputOverride {
94        name: "HDMI-A-1".into(),
95        wallpaper_path: "/fondos/mar.png".into(),
96        wallpaper_fit: "fill".into(),
97        order: 0,
98        scale_120: 0,
99        transform: String::new(),
100    }];
101    // El keymap de mirada como tabla (combinación · acción) — una tabla alta
102    // que ejercita el scroll del panel.
103    let keymap_rows = mirada_brain::Keymap::default().to_rows();
104    let atajos = Schema::new().section(
105        Section::new("mirada::atajos", "Atajos").icon("⌨").field(Field::table(
106            "bindings",
107            "Atajos de teclado",
108            vec![
109                allichay::Column::new("combo", "Combinación"),
110                allichay::Column::new("action", "Acción"),
111            ],
112            keymap_rows,
113        )),
114    );
115    let dientes: Vec<(&str, &str, Schema)> = vec![
116        ("⚙", "Sistema", sistema),
117        ("☸", "mirada", prefix(mirada_cfg.schema(), "mirada")),
118        ("🎛", "pata", prefix(pata_core::Config::preset().schema(), "pata")),
119        ("⌨", "Atajos", atajos),
120    ];
121
122    let mut state = AllichayState::new();
123    state.select(sel);
124
125    let rail_items: Vec<DockRailItem> = dientes
126        .iter()
127        .enumerate()
128        .map(|(i, _)| DockRailItem {
129            id: i as u64,
130            active: i == sel,
131        })
132        .collect();
133    let icons: Vec<String> = dientes.iter().map(|(icon, _, _)| (*icon).to_string()).collect();
134    let rail = dock_rail_view::<(), _, _, _>(
135        &rail_items,
136        52.0,
137        &DockRailPalette::from_theme(&theme),
138        move |id, size, color| {
139            let g = icons.get(id as usize).cloned().unwrap_or_default();
140            View::<()>::new(Style {
141                size: Size {
142                    width: percent(1.0),
143                    height: percent(1.0),
144                },
145                ..Default::default()
146            })
147            .text_aligned(g, size * 0.9, color, Alignment::Center)
148        },
149        |_id| (),
150        |_| None,
151    );
152    // 3 niveles: sidebar (items = secciones de la pestaña activa) | pestañas que
153    // sobresalen | canvas (contenido del item activo). El item se elige con el
154    // 3er arg (default 0) — útil para fotografiar una sección puntual (p. ej. la
155    // tabla del menú raíz de mirada).
156    let active = &dientes[sel.min(dientes.len() - 1)].2;
157    let item: usize = std::env::args()
158        .nth(3)
159        .and_then(|s| s.parse().ok())
160        .unwrap_or(0)
161        .min(active.sections.len().saturating_sub(1));
162
163    // Sidebar: lista de items (secciones) con su iconito.
164    let mut sidebar_kids: Vec<View<()>> = Vec::new();
165    for (i, sec) in active.sections.iter().enumerate() {
166        let act = i == item;
167        let icon = if sec.icon.is_empty() { "·" } else { sec.icon.as_str() };
168        let fg = if act { theme.fg_text } else { theme.fg_muted };
169        let row = View::<()>::new(Style {
170            flex_direction: FlexDirection::Row,
171            size: Size {
172                width: percent(1.0),
173                height: length(32.0),
174            },
175            align_items: Some(AlignItems::Center),
176            padding: Rect {
177                left: length(8.0),
178                right: length(8.0),
179                top: length(0.0),
180                bottom: length(0.0),
181            },
182            gap: Size {
183                width: length(6.0),
184                height: length(0.0),
185            },
186            ..Default::default()
187        })
188        .fill(if act { theme.bg_selected } else { theme.bg_panel })
189        .radius(4.0)
190        .children(vec![
191            View::<()>::new(Style {
192                size: Size {
193                    width: length(22.0),
194                    height: auto(),
195                },
196                ..Default::default()
197            })
198            .text_aligned(icon.to_string(), 14.0, fg, Alignment::Center),
199            View::<()>::new(Style {
200                size: Size {
201                    width: percent(1.0),
202                    height: auto(),
203                },
204                ..Default::default()
205            })
206            .text_aligned(sec.title.clone(), 12.5, fg, Alignment::Start),
207        ]);
208        sidebar_kids.push(row);
209    }
210    let sidebar = View::<()>::new(Style {
211        flex_direction: FlexDirection::Column,
212        size: Size {
213            width: length(232.0),
214            height: percent(1.0),
215        },
216        ..Default::default()
217    })
218    .fill(theme.bg_panel)
219    .children(sidebar_kids);
220
221    // Canvas: el contenido del item activo (una sección).
222    let one = Schema {
223        sections: vec![active.sections[item.min(active.sections.len() - 1)].clone()],
224    };
225    let canvas_content =
226        schema_panel::<(), _>(&one, &state, &theme, H as f32 - 40.0, |_m: AllichayMsg| ());
227    let canvas = View::<()>::new(Style {
228        flex_grow: 1.0,
229        size: Size {
230            width: percent(1.0),
231            height: percent(1.0),
232        },
233        padding: Rect {
234            top: length(0.0),
235            bottom: length(0.0),
236            left: length(46.0),
237            right: length(0.0),
238        },
239        ..Default::default()
240    })
241    .children(vec![canvas_content]);
242    let rail_overlay = View::<()>::new(Style {
243        position: Position::Absolute,
244        inset: Rect {
245            top: length(6.0),
246            left: length(0.0),
247            right: auto(),
248            bottom: auto(),
249        },
250        size: Size {
251            width: length(46.0),
252            height: auto(),
253        },
254        ..Default::default()
255    })
256    .children(vec![rail]);
257    let center = View::<()>::new(Style {
258        position: Position::Relative,
259        flex_grow: 1.0,
260        size: Size {
261            width: percent(0.0),
262            height: percent(1.0),
263        },
264        ..Default::default()
265    })
266    .fill(theme.bg_app)
267    .children(vec![canvas, rail_overlay]);
268    let v = View::<()>::new(Style {
269        flex_direction: FlexDirection::Row,
270        size: Size {
271            width: percent(1.0),
272            height: percent(1.0),
273        },
274        ..Default::default()
275    })
276    .fill(theme.bg_app)
277    .children(vec![sidebar, center]);
278
279    // Modo "overlay": pasá `overlay` como arg para ver `settings_overlay`
280    // (el modal embebible) sobre el panel como fondo de app.
281    let v = if std::env::args().any(|a| a == "overlay") {
282        let modal = settings_overlay::<(), _>(
283            "Configuración",
284            "Cerrar",
285            active,
286            &state,
287            &theme,
288            (W as f32, H as f32),
289            |_m: AllichayMsg| (),
290            (),
291        );
292        View::<()>::new(Style {
293            position: Position::Relative,
294            size: Size {
295                width: percent(1.0),
296                height: percent(1.0),
297            },
298            ..Default::default()
299        })
300        .children(vec![v, modal])
301    } else {
302        v
303    };
304
305    // view → layout → scene (misma secuencia que el eventloop).
306    let mut layout = LayoutTree::new();
307    let mounted = mount(&mut layout, v);
308    let mut ts = Typesetter::new();
309    let computed = {
310        let tmap = &mounted.text_measures;
311        layout
312            .compute_with_measure(mounted.root, (W as f32, H as f32), |nid, known, avail| {
313                match tmap.get(&nid) {
314                    Some(tm) => measure_text_node(&mut ts, tm, known, avail),
315                    None => taffy::Size::ZERO,
316                }
317            })
318            .expect("layout")
319    };
320    let mut scene = vello::Scene::new();
321    paint(&mut scene, &mounted, &computed, &mut ts, None, None);
322
323    let hal = pollster::block_on(Hal::new(None)).expect("hal");
324    let mut renderer = Renderer::new(&hal).expect("renderer");
325    let target = hal.device.create_texture(&wgpu::TextureDescriptor {
326        label: Some("dump-allichay"),
327        size: wgpu::Extent3d {
328            width: W,
329            height: H,
330            depth_or_array_layers: 1,
331        },
332        mip_level_count: 1,
333        sample_count: 1,
334        dimension: wgpu::TextureDimension::D2,
335        format: FMT,
336        usage: wgpu::TextureUsages::STORAGE_BINDING
337            | wgpu::TextureUsages::RENDER_ATTACHMENT
338            | wgpu::TextureUsages::COPY_SRC,
339        view_formats: &[],
340    });
341    let view = target.create_view(&wgpu::TextureViewDescriptor::default());
342    let [r, g, b, _] = theme.bg_app.components;
343    let bg = Color::from_rgba8((r * 255.0) as u8, (g * 255.0) as u8, (b * 255.0) as u8, 255);
344    renderer
345        .render_to_view(&hal, &scene, &view, W, H, bg)
346        .expect("render_to_view");
347
348    write_png(&hal, &target, &out);
349    eprintln!("dump_panel: escrito {out} ({W}x{H}) · diente {sel}");
350}
351
352fn write_png(hal: &Hal, target: &wgpu::Texture, path: &str) {
353    let unpadded = (W * 4) as usize;
354    let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
355    let padded = unpadded.div_ceil(align) * align;
356    let buf = hal.device.create_buffer(&wgpu::BufferDescriptor {
357        label: Some("readback"),
358        size: (padded * H as usize) as u64,
359        usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
360        mapped_at_creation: false,
361    });
362    let mut enc = hal
363        .device
364        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
365    enc.copy_texture_to_buffer(
366        wgpu::TexelCopyTextureInfo {
367            texture: target,
368            mip_level: 0,
369            origin: wgpu::Origin3d::ZERO,
370            aspect: wgpu::TextureAspect::All,
371        },
372        wgpu::TexelCopyBufferInfo {
373            buffer: &buf,
374            layout: wgpu::TexelCopyBufferLayout {
375                offset: 0,
376                bytes_per_row: Some(padded as u32),
377                rows_per_image: Some(H),
378            },
379        },
380        wgpu::Extent3d {
381            width: W,
382            height: H,
383            depth_or_array_layers: 1,
384        },
385    );
386    hal.queue.submit(std::iter::once(enc.finish()));
387    let slice = buf.slice(..);
388    let (tx, rx) = std::sync::mpsc::channel();
389    slice.map_async(wgpu::MapMode::Read, move |r| {
390        let _ = tx.send(r);
391    });
392    hal.device.poll(wgpu::PollType::wait_indefinitely());
393    rx.recv().unwrap().unwrap();
394    let data = slice.get_mapped_range();
395    let mut pixels = Vec::with_capacity((W * H * 4) as usize);
396    for row in 0..H as usize {
397        let s = row * padded;
398        pixels.extend_from_slice(&data[s..s + unpadded]);
399    }
400    drop(data);
401    buf.unmap();
402    let file = File::create(path).expect("png");
403    let mut enc = png::Encoder::new(BufWriter::new(file), W, H);
404    enc.set_color(png::ColorType::Rgba);
405    enc.set_depth(png::BitDepth::Eight);
406    let mut w = enc.write_header().unwrap();
407    w.write_image_data(&pixels).unwrap();
408}