cadrgtsecond/mosham - Change NBT2QCONKZ2E5I7HIQJUNQAUNJA6RPYYTUVZQCT6Z6ABU42A277AC

feat: Infos

Created by cadrgtsecond on January 8, 2026

NBT2QCONKZ2E5I7HIQJUNQAUNJA6RPYYTUVZQCT6Z6ABU42A277AC

Dependencies

In channels

main

Change contents

Replacement in src/render.rs at line 1 [5.34]

B:BD[5.34] → [5.35:82]

use std::{collections::HashMap, error::Error};

[5.34]

[5.82]

use std::{collections::HashMap, error::Error, rc::Rc};

Replacement in src/render.rs at line 11 [5.34]

B:BD[6.126] → [7.0:31]

B:BD[7.31] → [4.0:29]

    HEIGHT, RcLine, Ui, WIDTH,
    json_ui::{self, Config},

[6.126]

[6.191]

    RcLine, Ui,
    json_ui::{self, Config, InfoShowStyle},

Insertion in src/render.rs at line 15 [5.34]
[8.87]
[8.87]
```
const WIDTH: usize = 600;
const HEIGHT: usize = 400;
```

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

B:BD[7.187] → [7.187:281]

type ShapeCache = HashMap<RcLine, (bool, Vec<(json_ui::Face, FontIndex, i32, GlyphBuffer)>)>;

[7.187]

[5.315]

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

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

B:BD[4.31] → [4.31:100]

fn run_length(gbuf: &GlyphBuffer, upe: i32, font_size: i32) -> i32 {

[4.31]

[4.100]

fn run_length(gbuf: &GlyphBuffer, upe: i32, font_size: u32) -> i32 {

Replacement in src/render.rs at line 35 [5.34]

B:BD[4.143] → [4.143:191]

        .map(|i| i.x_advance * font_size / upe)

[4.143]

[4.191]

        .map(|i| i.x_advance * font_size as i32 / upe)

Replacement in src/render.rs at line 61 [5.34]

B:BD[7.831] → [7.831:926]

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

[7.831]

[7.926]

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

Replacement in src/render.rs at line 81 [5.34]

∅:D[9.278] → [7.1805:2048]

B:BD[7.1805] → [7.1805:2048]

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

[9.278]

[7.2048]

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

Replacement in src/render.rs at line 92 [5.34]

B:BD[7.2514] → [7.2514:2709]

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

[7.2514]

[7.2709]

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

Replacement in src/render.rs at line 94 [5.34]
B:BD[7.2723] → [7.2723:2747]
```
            (true, res)
```
[7.2723]
[7.2747]
```
            (true, res.into())
```
Replacement in src/render.rs at line 97 [5.34]
∅:D[2.22] → [7.2759:2774]
B:BD[7.2759] → [7.2759:2774]
```
        &res.1
```
[2.22]
[2.23]
```
        res.1.clone()
```

Deletion in src/render.rs at line 126 [5.34]

B:BD[5.3300] → [5.3300:3301]

B:BD[5.3301] → [4.217:231]

∅:D[4.231] → [10.0:41]

B:BD[5.3301] → [10.0:41]

∅:D[10.41] → [7.3190:3216]

B:BD[5.3301] → [7.3190:3216]

∅:D[7.3216] → [11.799:818]

B:BD[11.799] → [11.799:818]

B:BD[11.818] → [7.3217:3268]

∅:D[7.3268] → [11.818:843]

B:BD[11.818] → [11.818:843]

B:BD[11.843] → [7.3269:3323]

B:BD[7.3323] → [12.359:383]

B:BD[12.383] → [4.232:290]

∅:D[4.290] → [11.977:985]

∅:D[12.409] → [11.977:985]

B:BD[11.977] → [11.977:985]

B:BD[11.985] → [7.3348:3383]

B:BD[13.482] → [11.1246:1287]

B:BD[11.1287] → [6.498:611]

B:BD[6.611] → [7.3428:3524]

B:BD[6.1316] → [6.1316:1317]

B:BD[6.1317] → [7.3669:3823]

∅:D[13.649] → [5.4052:4053]

∅:D[6.1485] → [5.4052:4053]

∅:D[11.1555] → [5.4052:4053]

∅:D[7.3823] → [5.4052:4053]

B:BD[5.4052] → [5.4052:4053]

B:BD[5.4053] → [11.1556:1648]

B:BD[11.1648] → [4.291:472]

∅:D[4.472] → [14.59:120]

∅:D[7.3895] → [14.59:120]

B:BD[11.1839] → [14.59:120]

∅:D[14.120] → [11.1906:2002]

B:BD[11.1906] → [11.1906:2002]

B:BD[11.2002] → [4.473:518]

∅:D[4.518] → [11.2149:2202]

∅:D[7.3939] → [11.2149:2202]

B:BD[11.2149] → [11.2149:2202]

∅:D[12.674] → [11.2434:2470]

B:BD[11.2434] → [11.2434:2470]

B:BD[11.2470] → [15.0:105]

B:BD[15.105] → [4.519:568]

∅:D[4.568] → [15.151:267]

B:BD[15.151] → [15.151:267]

∅:D[15.267] → [11.2765:2828]

∅:D[6.1684] → [11.2765:2828]

B:BD[11.2765] → [11.2765:2828]

∅:D[11.2828] → [5.4617:4635]

B:BD[5.4617] → [5.4617:4635]

B:BD[5.5189] → [5.5189:5203]

B:BD[5.5213] → [5.5213:5214]

B:BD[5.5214] → [4.569:687]

∅:D[4.687] → [11.2945:2955]

∅:D[6.1795] → [11.2945:2955]

∅:D[7.4036] → [11.2945:2955]

B:BD[11.2945] → [11.2945:2955]

∅:D[13.975] → [5.5308:5314]

∅:D[11.2955] → [5.5308:5314]

B:BD[5.5308] → [5.5308:5314]


    #[inline]
    #[allow(clippy::too_many_arguments)]
    fn rasterize_segment(
        &mut self,
        buf: &mut [u8],
        size: (u32, u32),
        font: FontIndex,
        glyph_buffer: &GlyphBuffer,
        upe: i32,
        font_size: u32,
        color: [u8; 4],
        pos: &mut (usize, usize),
    ) {
        let fs = font_size as i32;
        for i in 0..glyph_buffer.len() {
            let ginfo = glyph_buffer.glyph_infos()[i];
            let gpos = glyph_buffer.glyph_positions()[i];
            let (metrics, data) = self.rasterize_glyph(font, ginfo.glyph_id as u16, font_size);
            let x_off = gpos.x_offset * fs / upe + metrics.xmin;
            let y_off = gpos.y_offset * fs / upe - metrics.ymin - metrics.height as i32;
            for row in 0..metrics.height {
                for column in 0..metrics.width {
                    let x = pos.0 + x_off as usize + column;
                    let y = pos.1 + y_off as usize + row;
                    let bidx = (x + y * size.0 as usize) * 4;
                    let sidx = column + row * metrics.width;
                    if bidx >= buf.len() {
                        break;
                    }
                    if x > size.0 as usize {
                        break;
                    }
                    for i in 0..3 {
                        let m = data[sidx] as u32;
                        let d = buf[bidx + i] as u32;
                        let s = color[i] as u32;
                        let res = (d * (255 - m) + s * m) / 255;
                        buf[bidx + i] = res as u8;
                    }
                    buf[bidx + 3] = 255;
                }
            }
            pos.0 += (gpos.x_advance * fs / upe) as usize;
            pos.1 += (gpos.y_advance * fs / upe) as usize;
        }
    }

Replacement in src/render.rs at line 133 [5.34]
B:BD[7.4183] → [7.4183:4209]
```
    pub size: (u32, u32),
```
[7.4183]
[7.4209]
```
    pub size: (usize, usize),
```

Replacement in src/render.rs at line 148 [5.34]

B:BD[7.4642] → [7.4642:4681]

            WIDTH,
            HEIGHT,

[7.4642]

[7.4681]

            WIDTH as u32,
            HEIGHT as u32,

Replacement in src/render.rs at line 153 [5.34]

B:BD[7.4844] → [7.4844:4898]

        let pixels = Pixels::new(WIDTH, HEIGHT, st)?;

[7.4844]

[7.4985]

        let pixels = Pixels::new(WIDTH as u32, HEIGHT as u32, st)?;

Replacement in src/render.rs at line 193 [5.34]

B:BD[4.770] → [4.770:1062]

    fn draw_background<T: Iterator<Item = usize> + Clone, U: Iterator<Item = usize>>(
        buf: &mut [u8],
        x: T,
        y: U,
        size: (u32, u32),
        color: [u8; 4],
    ) {
        for i in y {
            for j in x.clone() {
                if j >= size.0 as usize {

[4.770]

[4.1062]

    fn draw_background(&mut self, x: usize, y: usize, w: usize, h: usize, color: [u8; 4]) {
        let buf = self.pixels.frame_mut();
        for i in y..(y + h) {
            for j in x..(x + w) {
                if j >= self.size.0 {

Replacement in src/render.rs at line 200 [5.34]

B:BD[4.1107] → [4.1107:1149]

                if i >= size.1 as usize {

[4.1107]

[4.1149]

                if i >= self.size.1 {

Replacement in src/render.rs at line 203 [5.34]

B:BD[4.1195] → [4.1195:1253]

                let bidx = (j + i * size.0 as usize) * 4;

[4.1195]

[4.1253]

                let bidx = (j + i * self.size.0) * 4;

Insertion in src/render.rs at line 205 [5.34]

[4.1312]

            }
        }
    }
    #[allow(clippy::too_many_arguments)]
    fn rasterize_segment(
        &mut self,
        font: FontIndex,
        glyph_buffer: &GlyphBuffer,
        color: [u8; 4],
        pos: &mut (usize, usize),
    ) {
        let fs = self.font_size as i32;
        let upe = self.shaper.fonts[font].1.units_per_em();
        let buf = self.pixels.frame_mut();
        for i in 0..glyph_buffer.len() {
            let ginfo = glyph_buffer.glyph_infos()[i];
            let gpos = glyph_buffer.glyph_positions()[i];
            let (metrics, data) =
                self.rasterizer
                    .rasterize_glyph(font, ginfo.glyph_id as u16, self.font_size);
            let x_off = gpos.x_offset * fs / upe + metrics.xmin;
            let y_off = gpos.y_offset * fs / upe - metrics.ymin - metrics.height as i32;
            for row in 0..metrics.height {
                for column in 0..metrics.width {
                    let x = (pos.0 as i32 + x_off) as usize + column;
                    let y = (pos.1 as i32 + y_off) as usize + row;
                    let bidx = (x + y * self.size.0) * 4;
                    let sidx = column + row * metrics.width;
                    if bidx >= buf.len() {
                        break;
                    }
                    if x > self.size.0 {
                        break;
                    }
                    for i in 0..3 {
                        let m = data[sidx] as u32;
                        let d = buf[bidx + i] as u32;
                        let s = color[i] as u32;
                        let res = (d * (255 - m) + s * m) / 255;
                        buf[bidx + i] = res as u8;
                    }
                    buf[bidx + 3] = 255;
                }

Insertion in src/render.rs at line 254 [5.34]

[4.1326]


            pos.0 += (gpos.x_advance * fs / upe) as usize;
            pos.1 += (gpos.y_advance * fs / upe) as usize;

Replacement in src/render.rs at line 271 [5.34]

B:BD[4.1629] → [4.1629:1718]

        Self::draw_background(self.pixels.frame_mut(), 0.., 0.., self.size, default_bg);

[4.1629]

[5.5341]

        self.draw_background(0, 0, self.size.0, self.size.1, default_bg);
        let line_height = self.line_height() as usize;

Deletion in src/render.rs at line 274 [5.34]
B:BD[5.5342] → [4.1719:1774]
```
        let line_height = self.line_height() as usize;
```

Replacement in src/render.rs at line 276 [5.34]

B:BD[11.4209] → [7.6438:6527]

            for (face, font, upe, glyph_buffer) in self.shaper.make_runs(line.clone()) {

[11.4209]

[4.1775]

            for (face, font, glyph_buffer) in self.shaper.make_runs(line.clone()).iter() {
                let upe = self.shaper.fonts[*font].1.units_per_em();

Replacement in src/render.rs at line 279 [5.34]

B:BD[4.1835] → [4.1835:2180]

                    let run_length = run_length(glyph_buffer, *upe, self.font_size as i32);
                    Self::draw_background(
                        self.pixels.frame_mut(),
                        pos.0..(pos.0 + run_length as usize),
                        (pos.1 - line_height + 4)..(pos.1 + 4),
                        self.size,

[4.1835]

[4.2180]

                    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,

Replacement in src/render.rs at line 289 [5.34]

∅:D[4.2321] → [7.6527:6681]

B:BD[7.6527] → [7.6527:6681]

B:BD[7.6681] → [10.83:117]

∅:D[10.117] → [7.6716:6778]

B:BD[7.6716] → [7.6716:6778]

B:BD[7.6778] → [4.2322:2346]

∅:D[4.2346] → [7.6843:6873]

B:BD[7.6843] → [7.6843:6873]

∅:D[12.2152] → [7.6873:6892]

B:BD[7.6873] → [7.6873:6892]

                self.rasterizer.rasterize_segment(
                    self.pixels.frame_mut(),
                    self.size,
                    *font,
                    glyph_buffer,
                    *upe,
                    self.font_size,
                    fg,
                    &mut pos,
                );

[4.2321]

[11.4570]

                self.rasterize_segment(*font, glyph_buffer, fg, &mut pos);

Insertion in src/render.rs at line 295 [5.34]
[4.2402]
[16.158]
```
        let status_padding: usize = 10;
```

Replacement in src/render.rs at line 297 [5.34]

B:BD[16.159] → [4.2403:2451]

        pos.1 = (self.size.1 - 10u32) as usize;

[16.159]

[5.6831]

        pos.1 = self.size.1 - status_padding;

Replacement in src/render.rs at line 301 [5.34]

B:BD[4.2488] → [4.2488:2703]

            Self::draw_background(
                self.pixels.frame_mut(),
                0..,
                (pos.1 - line_height + 4)..(pos.1 + 4),
                self.size,
                bg,
            );

[4.2488]

[16.511]

            self.draw_background(0, pos.1 - line_height + 4, self.size.0, line_height, bg);

Replacement in src/render.rs at line 304 [5.34]

∅:D[16.522] → [7.6989:7084]

B:BD[11.4743] → [7.6989:7084]

        for (face, font, upe, glyph_buffer) in self.shaper.make_runs(ui.prompt_line.clone()) {

[16.522]

[4.2704]

        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();

Replacement in src/render.rs at line 307 [5.34]

B:BD[4.2760] → [4.2760:3081]

                let run_length = run_length(glyph_buffer, *upe, self.font_size as i32);
                Self::draw_background(
                    self.pixels.frame_mut(),
                    pos.0..(pos.0 + run_length as usize),
                    (pos.1 - line_height + 4)..(pos.1 + 4),
                    self.size,

[4.2760]

[4.3081]

                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,

Replacement in src/render.rs at line 320 [5.34]

∅:D[4.3300] → [7.7084:7222]

B:BD[7.7084] → [7.7084:7222]

B:BD[7.7222] → [10.145:175]

∅:D[10.175] → [7.7253:7307]

B:BD[7.7253] → [7.7253:7307]

B:BD[7.7307] → [4.3301:3321]

∅:D[16.554] → [7.7364:7390]

∅:D[4.3321] → [7.7364:7390]

B:BD[7.7364] → [7.7364:7390]

∅:D[12.2256] → [7.7390:7405]

B:BD[7.7390] → [7.7390:7405]

            self.rasterizer.rasterize_segment(
                self.pixels.frame_mut(),
                self.size,
                *font,
                glyph_buffer,
                *upe,
                self.font_size,
                fg,
                &mut pos,
            );

[4.3300]

[11.5091]

            self.rasterize_segment(*font, glyph_buffer, fg, &mut pos);

Replacement in src/render.rs at line 326 [5.34]

B:BD[7.7535] → [4.3322:3422]

            .map(|(_, _, upe, glyph_buffer)| run_length(glyph_buffer, *upe, self.font_size as i32))

[7.7535]

[7.7725]

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

Replacement in src/render.rs at line 332 [5.34]

B:BD[11.5994] → [4.3423:3483]

∅:D[4.3483] → [7.7746:7805]

B:BD[11.6043] → [7.7746:7805]

        pos.0 = self.size.0 as usize - text_width as usize;
        for (face, font, upe, glyph_buffer) in mode_line {

[11.5994]

[4.3484]

        pos.0 = self.size.0.saturating_sub(text_width as usize);
        for (face, font, glyph_buffer) in mode_line.iter() {
            let upe = self.shaper.fonts[*font].1.units_per_em();

Replacement in src/render.rs at line 336 [5.34]

B:BD[4.3540] → [4.3540:3861]

                let run_length = run_length(glyph_buffer, *upe, self.font_size as i32);
                Self::draw_background(
                    self.pixels.frame_mut(),
                    pos.0..(pos.0 + run_length as usize),
                    (pos.1 - line_height + 4)..(pos.1 + 4),
                    self.size,

[4.3540]

[4.3861]

                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,

Replacement in src/render.rs at line 349 [5.34]

∅:D[4.4080] → [7.7805:7943]

B:BD[7.7805] → [7.7805:7943]

B:BD[7.7943] → [10.199:229]

∅:D[10.229] → [7.7974:8028]

B:BD[7.7974] → [7.7974:8028]

B:BD[7.8028] → [4.4081:4101]

∅:D[16.586] → [7.8085:8111]

∅:D[4.4101] → [7.8085:8111]

B:BD[7.8085] → [7.8085:8111]

∅:D[12.2281] → [7.8111:8126]

B:BD[7.8111] → [7.8111:8126]

            self.rasterizer.rasterize_segment(
                self.pixels.frame_mut(),
                self.size,
                *font,
                glyph_buffer,
                *upe,
                self.font_size,
                fg,
                &mut pos,
            );

[4.4080]

[11.6185]

            self.rasterize_segment(*font, glyph_buffer, fg, &mut pos);
        }
        let info_padding_x: usize = 5;
        let info_padding_y: usize = 5;
        for info in &ui.infos {
            let mut runss = Vec::new();
            for line in &info.content {
                runss.push(self.shaper.make_runs(line.clone()));
            }
            let width = runss
                .iter()
                .map(|run| {
                    run.iter()
                        .map(|(_, font, glyph_buffer)| {
                            let upe = self.shaper.fonts[*font].1.units_per_em();
                            run_length(glyph_buffer, upe, self.font_size)
                        })
                        .sum::<i32>()
                })
                .max()
                .unwrap_or(0) as usize
                + info_padding_x * 2;
            let height = line_height * info.content.len() + info_padding_y * 2;
            let info_bg = info.face.bg.to_rgba(config).unwrap_or(default_bg);
            match info.style {
                InfoShowStyle::Prompt => {
                    pos.0 = self.size.0.saturating_sub(width);
                    pos.1 = self
                        .size
                        .1
                        .saturating_sub(height + line_height + status_padding);
                }
                InfoShowStyle::Modal => {
                    pos.0 = (self.size.0.saturating_sub(width)) / 2;
                    pos.1 = (self.size.1.saturating_sub(height)) / 2;
                }
                _ => {}
            }
            self.draw_background(pos.0, pos.1, width, height, info_bg);
            let start = pos.0 + info_padding_x;
            pos.1 += info_padding_y;
            for run in runss {
                pos.0 = start;
                pos.1 += line_height;
                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);
                }
            }

Insertion in src/render.rs at line 416 [5.34]
[11.6195]
[2.179]
Deletion in src/main.rs at line 20 [17.49]
B:BD[5.7133] → [5.7133:7183]
```
const WIDTH: u32 = 600;
const HEIGHT: u32 = 400;
```

Replacement in src/main.rs at line 30 [17.49]

B:BD[3.17] → [3.17:77]

    title: json_ui::Line,
    content: Rc<[json_ui::Line]>,

[3.17]

[3.77]

    title: RcLine,
    content: Vec<RcLine>,

Replacement in src/main.rs at line 160 [17.49]

B:BD[11.7200] → [11.7200:7247]

                    render.size = size.into();

[11.7200]

[12.2623]

                    render.size = (size.width as usize, size.height as usize);

Replacement in src/main.rs at line 216 [17.49]

B:BD[3.476] → [3.476:556]

                        title,
                        content: content.into(),

[3.476]

[3.556]

                        title: title.into(),
                        content: content.into_iter().map(From::from).collect(),