cadrgtsecond/mosham - Change CTPHEJ2S7MMSZTNVO4LFEYHMMTKYWB5PC54RMVJHMATN5TY45GPQC

Tis alive!

Created by cadrgtsecond on December 11, 2025

CTPHEJ2S7MMSZTNVO4LFEYHMMTKYWB5PC54RMVJHMATN5TY45GPQC

Dependencies

In channels

main

Change contents

Replacement in src/main.rs at line 15 [3.49]

B:BD[3.146] → [4.99:158]

    event_loop::{ActiveEventLoop, ControlFlow, EventLoop},

[3.146]

[3.188]

    event_loop::{ActiveEventLoop, ControlFlow, EventLoop, EventLoopProxy},

Insertion in src/main.rs at line 28 [3.49]
[2.246]
[2.246]
```
    #[allow(unused)]
```

Replacement in src/main.rs at line 111 [3.49]

B:BD[2.534] → [2.534:616]

async fn kakoune_thread_main(messages: smol::channel::Receiver<KakouneMessage>) {

[2.534]

[2.616]

async fn kakoune_thread_main(
    messages: smol::channel::Receiver<KakouneMessage>,
    event_loop_proxy: EventLoopProxy<AppMessage>,
) {

Replacement in src/main.rs at line 116 [3.49]
∅:D[2.671] → [5.217:248]
B:BD[5.217] → [5.217:248]
```
        .args(["-ui", "json"])
```
[2.671]
[5.248]
```
        .args(["-ui", "json", "src/main.rs"])
```

Replacement in src/main.rs at line 131 [3.49]

B:BD[2.1012] → [2.1012:1054]

            println!("{:?}---", content);

[2.1012]

[6.230]

            match content.inner {
                json_ui::Request::Draw(lines, default_face, padding_face) => {
                    event_loop_proxy
                        .send_event(AppMessage::Draw(lines, default_face, padding_face))
                        .unwrap();
                }
                json_ui::Request::DrawStatus(_atoms, _atoms1, _face) => {}
                json_ui::Request::MenuShow(_items, _coord, _face, _face1, _menu_show_style) => {}
                json_ui::Request::MenuSelect(_) => {}
                json_ui::Request::MenuHide() => {}
                json_ui::Request::InfoShow(_, _, _coord, _face, _info_show_style) => {}
                json_ui::Request::InfoHide(_) => {}
                json_ui::Request::SetCursor(_set_cursor_mode, _coord) => {}
                json_ui::Request::SetUiOptions(_) => {}
                json_ui::Request::Refresh(_) => {}
            };

Replacement in src/main.rs at line 153 [3.49]

B:BD[2.1194] → [2.1194:1296]

                KakouneMessage::ResizeScreen(x, y) => {
                    println!("{}, {}", x, y);

[2.1194]

[2.1296]

                KakouneMessage::ResizeScreen(columns, rows) => {

Replacement in src/main.rs at line 155 [3.49]

B:BD[2.1327] → [2.1327:1425]

                        serde_json::to_vec(&Rpc::from(json_ui::Response::Resize(x, y))).unwrap();

[2.1327]

[2.1425]

                        serde_json::to_vec(&Rpc::from(json_ui::Response::Resize(rows, columns)))
                            .unwrap();

Insertion in src/main.rs at line 163 [3.49]

[2.1572]

[5.743]

}
#[derive(Debug)]
enum AppMessage {
    Draw(Vec<json_ui::Line>, json_ui::Face, json_ui::Face),

Insertion in src/main.rs at line 175 [3.49]
[2.1629]
[7.1819]
```
    lines: Vec<json_ui::Line>,
```

Replacement in src/main.rs at line 179 [3.49]

B:BD[7.1833] → [7.1833:1880]

    fn new() -> Result<Self, Box<dyn Error>> {

[7.1833]

[2.1630]

    fn new(evp: EventLoopProxy<AppMessage>) -> Result<Self, Box<dyn Error>> {

Replacement in src/main.rs at line 184 [3.49]

B:BD[7.1973] → [2.1686:1780]

            kakoune_thread: std::thread::spawn(|| smol::block_on(kakoune_thread_main(recv))),

[7.1973]

[2.1780]

            kakoune_thread: std::thread::spawn(|| smol::block_on(kakoune_thread_main(recv, evp))),

Insertion in src/main.rs at line 186 [3.49]
[2.1811]
[7.1973]
```
            lines: Vec::new(),
```

Replacement in src/main.rs at line 191 [3.49]

B:BD[7.1992] → [7.1992:2308]

B:BD[7.2308] → [8.114:151]

∅:D[8.151] → [7.2335:2369]

B:BD[7.2335] → [7.2335:2369]

fn redraw(rs: &mut RenderState, fs: &mut FontState) {
    let mut ubuf = UnicodeBuffer::new();
    // ubuf.push_str("പിന്നോട്ടു മാത്രം മടങ്ങുന്ന കാലുകൊണ്ടല്ലയോ മുന്നോട്ടു പായുന്നിതാളുകൾ ");
    ubuf.push_str("A test of will");
    let gbuf = fs.shape(0, ubuf);

[7.1992]

[7.2369]

fn redraw(rs: &mut RenderState, fs: &mut FontState, lines: &[json_ui::Line]) {
    let line_height = fs.fontdue_faces[0]
        .vertical_line_metrics(32.0)
        .map(|i| i.new_line_size)
        .unwrap_or(40.0);

Replacement in src/main.rs at line 197 [3.49]

B:BD[7.2388] → [7.2388:2409]

B:BD[7.2409] → [8.152:204]

    let mut y = 100;
    let upe = fs.rustybuzz_faces[0].units_per_em();

[7.2388]

[7.2409]

    let mut y = line_height as i32;
    for line in lines {
        let mut ubuf = UnicodeBuffer::new();
        for atom in line {
            ubuf.push_str(&atom.contents);
        }
        let gbuf = fs.shape(0, ubuf);
        let upe = fs.rustybuzz_faces[0].units_per_em();

Replacement in src/main.rs at line 206 [3.49]

B:BD[7.2410] → [7.2410:2654]

B:BD[7.2654] → [8.205:319]

    // >i vj
    for (gpos, ginfo) in gbuf.glyph_positions().iter().zip(gbuf.glyph_infos()) {
        let (metrics, data) = fs.render_glyph(0, ginfo.glyph_id as u16);
        for i in 0..metrics.width {
            for j in 0..metrics.height {
                let x_offset = gpos.x_offset * 32 / upe;
                let y_offset = gpos.y_offset * 32 / upe;

[7.2410]

[8.319]

        // >i vj
        for (gpos, ginfo) in gbuf.glyph_positions().iter().zip(gbuf.glyph_infos()) {
            let (metrics, data) = fs.render_glyph(0, ginfo.glyph_id as u16);
            for i in 0..metrics.width {
                for j in 0..metrics.height {
                    let x_offset = gpos.x_offset * 32 / upe;
                    let y_offset = gpos.y_offset * 32 / upe;

Replacement in src/main.rs at line 214 [3.49]

B:BD[8.320] → [8.320:474]

∅:D[8.474] → [7.2832:2910]

B:BD[7.2832] → [7.2832:2910]

                let py = y + j as i32 - y_offset - metrics.height as i32 - metrics.ymin;
                let px = x + i as i32 + x_offset + metrics.xmin;
                let pidx = (py * rs.pixmap.width() as i32 + px) as usize * 4;

[8.320]

[3.274]

                    let py = y + j as i32 - y_offset - metrics.height as i32 - metrics.ymin;
                    let px = x + i as i32 + x_offset + metrics.xmin;
                    let pidx = (py * rs.pixmap.width() as i32 + px) as usize * 4;

Replacement in src/main.rs at line 218 [3.49]

B:BD[3.275] → [7.2911:3067]

                if pidx >= rs.pixmap.data().len() {
                    continue;
                }
                let didx = (j * metrics.width + i) * 3;

[3.275]

[7.3067]

                    if pidx >= rs.pixmap.data().len() {
                        continue;
                    }
                    let didx = (j * metrics.width + i) * 3;

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

B:BD[7.3068] → [7.3068:3234]

                let data_mut = rs.pixmap.data_mut();
                for k in 0..3 {
                    data_mut[pidx + k] = data_mut[pidx + k].max(data[didx + k]);

[7.3068]

[7.3234]

                    let data_mut = rs.pixmap.data_mut();
                    for k in 0..3 {
                        data_mut[pidx + k] = data_mut[pidx + k].max(data[didx + k]);
                    }
                    data_mut[pidx + 3] = 255;

Deletion in src/main.rs at line 229 [3.49]
B:BD[7.3252] → [7.3252:3294]
```
                data_mut[pidx + 3] = 255;
```

Insertion in src/main.rs at line 230 [3.49]

[7.3308]

            x += gpos.x_advance * 32 / upe;
            y += gpos.y_advance * 32 / upe;

Replacement in src/main.rs at line 233 [3.49]

B:BD[7.3318] → [8.475:555]

        x += gpos.x_advance * 32 / upe;
        y += gpos.y_advance * 32 / upe;

[7.3318]

[7.3475]

        y += line_height as i32;
        x = 0;

Replacement in src/main.rs at line 241 [3.49]
∅:D[9.551] → [3.275:309]
B:BD[3.275] → [3.275:309]
```
impl ApplicationHandler for App {
```
[9.551]
[4.1250]
```
impl ApplicationHandler<AppMessage> for App {
```

Replacement in src/main.rs at line 255 [3.49]

B:BD[4.1474] → [7.3482:3536]

                    redraw(rs, &mut self.font_state);

[4.1474]

[3.1018]

                    redraw(rs, &mut self.font_state, &self.lines);

Insertion in src/main.rs at line 279 [3.49]

[3.1180]

    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: AppMessage) {
        match event {
            AppMessage::Draw(lines, _default_face, _padding_face) => {
                self.lines = lines;
                if let Some(rs) = &self.render_state {
                    rs.window.request_redraw();
                }
            }
        }
    }

Replacement in src/main.rs at line 292 [3.49]

B:BD[3.1195] → [3.1195:1243]

    let event_loop = EventLoop::new().unwrap();

[3.1195]

[3.1243]

    let event_loop = EventLoop::<AppMessage>::with_user_event().build().unwrap();

Replacement in src/main.rs at line 294 [3.49]

B:BD[3.1295] → [6.339:378]

    let mut app = App::new().unwrap();

[3.1295]

[6.378]

    let mut app = App::new(event_loop.create_proxy()).unwrap();

Replacement in src/json_ui.rs at line 57 [10.50]

B:BD[10.939] → [10.939:977]

    face: Face,
    contents: String,

[10.939]

[10.977]

    pub face: Face,
    pub contents: String,

Replacement in src/json_ui.rs at line 133 [10.50]
B:BD[11.1586] → [11.1586:1607]
```
    jsonrpc: String,
```
[11.1586]
[11.1607]
```
    pub jsonrpc: String,
```
Replacement in src/json_ui.rs at line 135 [10.50]
B:BD[11.1629] → [11.1629:1643]
```
    inner: T,
```
[11.1629]
[11.1643]
```
    pub inner: T,
```