cadrgtsecond/mosham - Change 3E7ON5LK5KELT7NX7O2DRSVSQQGVW3HU3LFTQGGCJ5PIRZDWD56QC

feat: Prompt menu!

Created by cadrgtsecond on January 8, 2026

3E7ON5LK5KELT7NX7O2DRSVSQQGVW3HU3LFTQGGCJ5PIRZDWD56QC

Dependencies

In channels

main

Change contents

Replacement in src/render.rs at line 12 [3.34]

B:BD[2.72] → [2.72:116]

    json_ui::{self, Config, InfoShowStyle},

[2.72]

[4.191]

    json_ui::{self, Config, InfoShowStyle, MenuShowStyle},

Replacement in src/render.rs at line 23 [3.34]

B:BD[5.187] → [2.172:262]

type ShapeCache = HashMap<RcLine, (bool, Rc<[(json_ui::Face, FontIndex, GlyphBuffer)]>)>;

[5.187]

[3.315]

type ShapeCache = HashMap<RcLine, (bool, Rc<[Run]>)>;

Replacement in src/render.rs at line 25 [3.34]

B:BD[3.316] → [5.282:427]

#[derive(Default)]
pub struct Shaper {
    pub fonts: Vec<(Vec<u8>, rustybuzz::Face<'static>)>,
    pub cache: ShapeCache,
    pub plans: Plans,

[3.316]

[6.223]

struct Run {
    face: json_ui::Face,
    font: FontIndex,
    glyph_buffer: GlyphBuffer,
    upe: i32,

Replacement in src/render.rs at line 32 [3.34]

B:BD[7.31] → [2.263:332]

∅:D[2.332] → [7.100:143]

B:BD[7.100] → [7.100:143]

B:BD[7.143] → [2.333:388]

∅:D[2.388] → [7.191:213]

B:BD[7.191] → [7.191:213]

fn run_length(gbuf: &GlyphBuffer, upe: i32, font_size: u32) -> i32 {
    gbuf.glyph_positions()
        .iter()
        .map(|i| i.x_advance * font_size as i32 / upe)
        .sum::<i32>()

[7.31]

[7.213]

impl Run {
    fn length(&self, font_size: i32) -> usize {
        self.glyph_buffer
            .glyph_positions()
            .iter()
            .map(|i| i.x_advance * font_size / self.upe)
            .sum::<i32>() as usize
    }
}
#[derive(Default)]
struct Shaper {
    fonts: Vec<(Vec<u8>, rustybuzz::Face<'static>)>,
    cache: ShapeCache,
    plans: Plans,

Replacement in src/render.rs at line 71 [3.34]

B:BD[5.831] → [2.389:482]

    fn make_runs(&mut self, line: RcLine) -> Rc<[(json_ui::Face, FontIndex, GlyphBuffer)]> {

[5.831]

[5.926]

    fn make_runs(&mut self, line: RcLine) -> Rc<[Run]> {

Replacement in src/render.rs at line 91 [3.34]

B:BD[8.278] → [2.483:563]

                        res.push((atom.face.clone(), curr_font, glyph_buffer));

[8.278]

[5.2048]

                        res.push(Run {
                            face: atom.face.clone(),
                            font: curr_font,
                            glyph_buffer,
                            upe: rb_font.units_per_em(),
                        });

Replacement in src/render.rs at line 107 [3.34]

B:BD[5.2514] → [2.564:636]

                res.push((atom.face.clone(), curr_font, glyph_buffer));

[5.2514]

[5.2709]

                res.push(Run {
                    face: atom.face.clone(),
                    font: curr_font,
                    glyph_buffer,
                    upe: rb_font.units_per_em(),
                });

Deletion in src/render.rs at line 229 [3.34]
B:BD[2.1209] → [2.1209:1250]
```
    #[allow(clippy::too_many_arguments)]
```

Replacement in src/render.rs at line 232 [3.34]

B:BD[2.1296] → [2.1296:1381]

        font: FontIndex,
        glyph_buffer: &GlyphBuffer,
        color: [u8; 4],

[2.1296]

[2.1381]

        run: &Run,
        config: &Config,
        default_fg: [u8; 4],

Replacement in src/render.rs at line 238 [3.34]

B:BD[2.1463] → [2.1463:1523]

        let upe = self.shaper.fonts[font].1.units_per_em();

[2.1463]

[2.1523]

        let bg = run.face.bg.to_rgba(config);
        let fg = run.face.fg.to_rgba(config).unwrap_or(default_fg);
        let line_height = self.line_height() as usize;
        if let Some(bg) = bg {
            self.draw_background(
                pos.0,
                pos.1 - line_height + 4,
                run.length(self.font_size as i32),
                line_height,
                bg,
            );
        }
        let Run {
            upe,
            glyph_buffer,
            font,
            ..
        } = run;

Replacement in src/render.rs at line 265 [3.34]

B:BD[2.1787] → [2.1787:1870]

                    .rasterize_glyph(font, ginfo.glyph_id as u16, self.font_size);

[2.1787]

[2.1870]

                    .rasterize_glyph(*font, ginfo.glyph_id as u16, self.font_size);

Replacement in src/render.rs at line 285 [3.34]

B:BD[2.2705] → [2.2705:2754]

                        let s = color[i] as u32;

[2.2705]

[2.2754]

                        let s = fg[i] as u32;

Replacement in src/render.rs at line 314 [3.34]

B:BD[6.4209] → [2.3202:3362]

∅:D[2.3362] → [7.1775:1835]

B:BD[5.6527] → [7.1775:1835]

B:BD[7.1835] → [2.3363:3651]

∅:D[2.3651] → [7.2180:2321]

B:BD[7.2180] → [7.2180:2321]

B:BD[7.2321] → [2.3652:3727]

            for (face, font, glyph_buffer) in self.shaper.make_runs(line.clone()).iter() {
                let upe = self.shaper.fonts[*font].1.units_per_em();
                if let Some(bg) = face.bg.to_rgba(config) {
                    let run_length = run_length(glyph_buffer, upe, self.font_size);
                    self.draw_background(
                        pos.0,
                        pos.1 - line_height + 4,
                        run_length as usize,
                        line_height,
                        bg,
                    );
                }
                let fg = face.fg.to_rgba(config).unwrap_or(default_fg);
                self.rasterize_segment(*font, glyph_buffer, fg, &mut pos);

[6.4209]

[6.4570]

            for run in self.shaper.make_runs(line.clone()).iter() {
                self.rasterize_segment(run, config, default_fg, &mut pos);

Replacement in src/render.rs at line 330 [3.34]

B:BD[9.522] → [2.3909:4071]

∅:D[2.4071] → [7.2704:2760]

B:BD[5.7084] → [7.2704:2760]

B:BD[7.2760] → [2.4072:4336]

∅:D[2.4336] → [7.3081:3300]

B:BD[7.3081] → [7.3081:3300]

B:BD[7.3300] → [2.4337:4408]

        for (face, font, glyph_buffer) in self.shaper.make_runs(ui.prompt_line.clone()).iter() {
            let upe = self.shaper.fonts[*font].1.units_per_em();
            if let Some(bg) = face.bg.to_rgba(config) {
                let run_length = run_length(glyph_buffer, upe, self.font_size);
                self.draw_background(
                    pos.0,
                    pos.1 - line_height + 4,
                    run_length as usize,
                    line_height,
                    bg,
                );
            }
            let fg = face
                .fg
                .to_rgba(config)
                .unwrap_or(ui.line_face.fg.to_rgba(config).unwrap_or(default_fg));
            self.rasterize_segment(*font, glyph_buffer, fg, &mut pos);

[9.522]

[6.5091]

        for run in self.shaper.make_runs(ui.prompt_line.clone()).iter() {
            let line_fg = ui.line_face.fg.to_rgba(config).unwrap_or(default_fg);
            self.rasterize_segment(run, config, line_fg, &mut pos);

Replacement in src/render.rs at line 338 [3.34]

B:BD[5.7535] → [2.4409:4600]

            .map(|(_, font, glyph_buffer)| {
                let upe = self.shaper.fonts[*font].1.units_per_em();
                run_length(glyph_buffer, upe, self.font_size)
            })

[5.7535]

[5.7725]

            .map(|run| run.length(self.font_size as i32) as i32)

Replacement in src/render.rs at line 342 [3.34]

B:BD[2.4666] → [2.4666:4792]

∅:D[2.4792] → [7.3484:3540]

B:BD[5.7805] → [7.3484:3540]

B:BD[7.3540] → [2.4793:5057]

∅:D[2.5057] → [7.3861:3904]

B:BD[7.3861] → [7.3861:3904]

        for (face, font, glyph_buffer) in mode_line.iter() {
            let upe = self.shaper.fonts[*font].1.units_per_em();
            if let Some(bg) = face.bg.to_rgba(config) {
                let run_length = run_length(glyph_buffer, upe, self.font_size);
                self.draw_background(
                    pos.0,
                    pos.1 - line_height + 4,
                    run_length as usize,
                    line_height,
                    bg,
                );

[2.4666]

[7.3904]

        for run in mode_line.iter() {
            let mode_fg = ui.line_face.fg.to_rgba(config).unwrap_or(default_fg);
            self.rasterize_segment(run, config, mode_fg, &mut pos);
        }
        let menu_padding_x: usize = 2;
        let menu_padding_y: usize = 2;
        let mut menu_space: usize = 0;
        for menu in &ui.menus {
            let lines: Vec<_> = menu
                .content
                .iter()
                .map(|line| self.shaper.make_runs(line.clone()))
                .collect();
            let menu_bg = menu.menu_face.bg.to_rgba(config).unwrap_or(default_bg);
            let menu_fg = menu.menu_face.fg.to_rgba(config).unwrap_or(default_fg);
            let selected_fg = menu.selected_face.fg.to_rgba(config).unwrap_or(default_fg);
            let selected_bg = menu.selected_face.bg.to_rgba(config).unwrap_or(default_bg);
            match menu.style {
                MenuShowStyle::Prompt => {
                    let width = self.font_size * 15;
                    let num_width = self.size.0 / width as usize;
                    let num_height = usize::min(menu.content.len() / num_width, 10);
                    println!("{} {}", num_height, num_width);
                    let width = self.size.0 / num_width;
                    menu_space = line_height * num_height + menu_padding_y * 2;
                    for (i, line) in lines.into_iter().enumerate() {
                        let x = i % num_width;
                        let y = i / num_width;
                        if y >= num_height {
                            break;
                        }
                        pos.0 = x * width + menu_padding_x;
                        pos.1 = (self.size.1).saturating_sub(
                            line_height * (y + 1) + menu_padding_y + status_padding,
                        );
                        let (fg, bg) = if menu.selected == i {
                            (selected_fg, selected_bg)
                        } else {
                            (menu_fg, menu_bg)
                        };
                        self.draw_background(
                            pos.0,
                            pos.1 - line_height + 4,
                            width,
                            line_height,
                            bg,
                        );
                        for run in line.iter() {
                            self.rasterize_segment(run, config, fg, &mut pos);
                        }
                    }
                }
                _ => {}

Deletion in src/render.rs at line 401 [3.34]

B:BD[7.3918] → [7.3918:4080]

B:BD[7.4080] → [2.5058:5129]

            let fg = face
                .fg
                .to_rgba(config)
                .unwrap_or(ui.line_face.fg.to_rgba(config).unwrap_or(default_fg));
            self.rasterize_segment(*font, glyph_buffer, fg, &mut pos);

Replacement in src/render.rs at line 406 [3.34]

B:BD[2.5250] → [2.5250:5439]

            let mut runss = Vec::new();
            for line in &info.content {
                runss.push(self.shaper.make_runs(line.clone()));
            }
            let width = runss

[2.5250]

[2.5439]

            let lines: Vec<_> = info
                .content
                .iter()
                .map(|line| self.shaper.make_runs(line.clone()))
                .collect();
            let width = lines

Replacement in src/render.rs at line 415 [3.34]

B:BD[2.5523] → [2.5523:5762]

                        .map(|(_, font, glyph_buffer)| {
                            let upe = self.shaper.fonts[*font].1.units_per_em();
                            run_length(glyph_buffer, upe, self.font_size)
                        })

[2.5523]

[2.5762]

                        .map(|run| run.length(self.font_size as i32) as i32)

Replacement in src/render.rs at line 430 [3.34]

B:BD[2.6305] → [2.6305:6385]

                        .saturating_sub(height + line_height + status_padding);

[2.6305]

[2.6385]

                        .saturating_sub(height + line_height + status_padding + menu_space);

Insertion in src/render.rs at line 439 [3.34]
[2.6712]
[2.6712]
Replacement in src/render.rs at line 442 [3.34]
B:BD[2.6797] → [2.6797:6828]
```
            for run in runss {
```
[2.6797]
[2.6828]
```
            for runs in lines {
```

Replacement in src/render.rs at line 445 [3.34]

B:BD[2.6897] → [2.6897:7790]

                for (face, font, glyph_buffer) in run.iter() {
                    let upe = self.shaper.fonts[*font].1.units_per_em();
                    if let Some(bg) = face.bg.to_rgba(config) {
                        let run_length = run_length(glyph_buffer, upe, self.font_size);
                        self.draw_background(
                            pos.0,
                            pos.1 - line_height + 4,
                            run_length as usize,
                            line_height,
                            bg,
                        );
                    }
                    let fg = info
                        .face
                        .fg
                        .to_rgba(config)
                        .unwrap_or(info.face.fg.to_rgba(config).unwrap_or(default_fg));
                    self.rasterize_segment(*font, glyph_buffer, fg, &mut pos);

[2.6897]

[2.7790]

                for run in runs.iter() {
                    let info_fg = info.face.fg.to_rgba(config).unwrap_or(default_fg);
                    self.rasterize_segment(run, config, info_fg, &mut pos);

Insertion in src/main.rs at line 37 [11.49]

[10.746]

[6.6293]

struct Menu {
    content: Vec<RcLine>,
    anchor: json_ui::Coord,
    selected_face: json_ui::Face,
    menu_face: json_ui::Face,
    style: json_ui::MenuShowStyle,
    selected: usize,
}

Insertion in src/main.rs at line 53 [11.49]
[12.189]
[6.6358]
```
    menus: Vec<Menu>,
```

Replacement in src/main.rs at line 223 [11.49]

B:BD[12.311] → [12.311:354]

                Request::MenuHide(_) => {}

[12.311]

[12.354]

                Request::MenuHide(_) => {
                    self.ui.menus.clear();
                }

Replacement in src/main.rs at line 235 [11.49]

B:BD[13.6227] → [12.674:814]

                Request::MenuShow(_content, _anchor, _selected_face, _menu_face, _style) => {}
                Request::MenuSelect(_) => {}

[13.6227]

[13.6251]

                Request::MenuShow(content, anchor, selected_face, menu_face, style) => {
                    self.ui.menus.retain(|menu| menu.style != style);
                    self.ui.menus.push(Menu {
                        content: content.into_iter().map(From::from).collect(),
                        anchor,
                        selected_face,
                        menu_face,
                        style,
                        selected: 0,
                    });
                    println!("{}", self.ui.menus.len());
                }
                Request::MenuSelect(index) => {
                    if let Some(menu) = self.ui.menus.last_mut() {
                        menu.selected = index[0] as usize;
                    }
                }