xei-editor 3.0.9

xei (晴) — a modern terminal text editor in Rust with Vim-modal editing, syntax highlighting, file explorer, built-in terminal, and theming
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Kitty-graphics placement registry for inline preview images.
//!
//! `ui.rs` queues (path, x, y, w_cells, rows) requests each frame; after the
//! ratatui draw the registry diffs them against what's on screen — decoding
//! and resizing once per (path, width), re-placing on scroll, and deleting
//! anything no longer requested so mode switches can't strand ghost images.

use std::collections::HashMap;
use std::io::{self, Write};

use xei_core::media::ImageAsset;
use xei_core::App;

use crate::gpu_frame;
use crate::kitty_gfx;
use crate::term_caps::TerminalCaps;

struct Placed {
    asset: ImageAsset,
    /// Last placement (x, y) — re-place only when it moves.
    at: Option<(u16, u16)>,
    used: bool,
}

pub struct GfxRegistry {
    /// key: "path|w_cells"
    items: HashMap<String, Placed>,
    next_id: u32,
}

impl GfxRegistry {
    pub fn new() -> Self {
        Self {
            items: HashMap::new(),
            next_id: 300,
        }
    }

    /// Reconcile requested placements with the screen. Returns true when any
    /// stdout write happened (caller re-asserts the caret).
    pub fn flush(
        &mut self,
        app: &mut App,
        caps: &TerminalCaps,
        editor_cursor: Option<(u16, u16)>,
    ) -> bool {
        let enabled = kitty_gfx::available(app.gpu_acc && app.gpu_graphics, caps);
        if !enabled && self.items.is_empty() {
            return false;
        }
        let requests: Vec<(String, u16, u16, u16, u16)> = if enabled {
            std::mem::take(&mut app.preview_gfx)
        } else {
            app.preview_gfx.clear();
            Vec::new()
        };

        for p in self.items.values_mut() {
            p.used = false;
        }

        let mut painted = false;
        let use_sync = gpu_frame::should_sync(app.gpu_acc, caps);
        let cell_px = app.cell_px_or_default();
        let mut out = io::stdout();

        for (path, x, y, w_cells, _rows) in requests {
            let key = format!("{path}|{w_cells}");
            if !self.items.contains_key(&key) {
                let Ok(mut asset) = ImageAsset::load(std::path::Path::new(&path), cell_px)
                else {
                    continue;
                };
                asset.width_cells = w_cells;
                asset.kitty_id = self.next_id;
                self.next_id = self.next_id.wrapping_add(1).max(300);
                asset.rebuild_cache(cell_px);
                self.items.insert(
                    key.clone(),
                    Placed {
                        asset,
                        at: None,
                        used: false,
                    },
                );
            }
            let Some(item) = self.items.get_mut(&key) else {
                continue;
            };
            item.used = true;
            if item.at == Some((x, y)) {
                continue; // already exactly there
            }
            let a = &item.asset;
            if kitty_gfx::place_rgba_rect_b64(
                &mut out,
                a.kitty_id,
                a.cached_w,
                a.cached_h,
                Some(&a.cached_b64),
                &a.cached_rgba,
                x as u32,
                y as u32,
                editor_cursor,
                use_sync,
            )
            .is_ok()
            {
                item.at = Some((x, y));
                painted = true;
            }
        }

        // Anything not requested this frame disappears (scroll-out, close,
        // mode switch, resize).
        let stale: Vec<String> = self
            .items
            .iter()
            .filter(|(_, p)| !p.used)
            .map(|(k, _)| k.clone())
            .collect();
        for k in stale {
            if let Some(p) = self.items.remove(&k) {
                let _ = kitty_gfx::delete_image_flush(&mut out, p.asset.kitty_id);
                painted = true;
            }
        }
        let _ = out.flush();
        painted
    }
}