egui 0.34.1

An easy-to-use immediate mode GUI that runs on both web and native
Documentation 
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197

use emath::TSTransform;

use crate::{Context, Galley, Id};

use super::{CCursorRange, text_cursor_state::is_word_char};

/// AccessKit's `word_starts` uses `u8` indices, so text runs cannot exceed this length.
pub(crate) const MAX_CHARS_PER_TEXT_RUN: usize = 255;

/// Convert a (row, column) layout cursor position to a text run node ID and character index,
/// accounting for rows that are split into multiple text runs.
fn text_run_position(parent_id: Id, row: usize, column: usize) -> accesskit::TextPosition {
    // When column lands exactly on a chunk boundary (e.g., 255), it refers to
    // the end of the previous chunk, not the start of a new one.
    let chunk_index = if column > 0 && column.is_multiple_of(MAX_CHARS_PER_TEXT_RUN) {
        column / MAX_CHARS_PER_TEXT_RUN - 1
    } else {
        column / MAX_CHARS_PER_TEXT_RUN
    };
    let character_index = column - chunk_index * MAX_CHARS_PER_TEXT_RUN;
    accesskit::TextPosition {
        node: parent_id.with(row).with(chunk_index).accesskit_id(),
        character_index,
    }
}

/// Update accesskit with the current text state.
pub fn update_accesskit_for_text_widget(
    ctx: &Context,
    widget_id: Id,
    cursor_range: Option<CCursorRange>,
    role: accesskit::Role,
    global_from_galley: TSTransform,
    galley: &Galley,
) {
    let parent_id = ctx.accesskit_node_builder(widget_id, |builder| {
        let parent_id = widget_id;

        if let Some(cursor_range) = &cursor_range {
            let anchor = galley.layout_from_cursor(cursor_range.secondary);
            let focus = galley.layout_from_cursor(cursor_range.primary);
            builder.set_text_selection(accesskit::TextSelection {
                anchor: text_run_position(parent_id, anchor.row, anchor.column),
                focus: text_run_position(parent_id, focus.row, focus.column),
            });
        }

        builder.set_role(role);

        parent_id
    });

    let Some(parent_id) = parent_id else {
        return;
    };

    let mut prev_row_ended_with_newline = true;

    for (row_index, row) in galley.rows.iter().enumerate() {
        let glyph_count = row.glyphs.len();
        let mut value = String::with_capacity(glyph_count);
        let mut character_lengths = Vec::<u8>::with_capacity(glyph_count);
        let mut character_positions = Vec::<f32>::with_capacity(glyph_count);
        let mut character_widths = Vec::<f32>::with_capacity(glyph_count);
        let mut word_starts = Vec::<usize>::new();
        // For soft-wrapped continuation rows, treat the start as a word
        // boundary so the first word character gets a `word_starts` entry.
        // Paragraph-starting runs (first row or after a newline) get an
        // implicit word start from AccessKit, so they don't need this.
        let mut was_at_word_end = !prev_row_ended_with_newline;

        for glyph in &row.glyphs {
            let is_word_char = is_word_char(glyph.chr);
            if is_word_char && was_at_word_end {
                word_starts.push(character_lengths.len());
            }
            was_at_word_end = !is_word_char;
            let old_len = value.len();
            value.push(glyph.chr);
            character_lengths.push((value.len() - old_len) as _);
            character_positions.push(glyph.pos.x - row.pos.x);
            character_widths.push(glyph.advance_width);
        }

        if row.ends_with_newline {
            value.push('\n');
            character_lengths.push(1);
            character_positions.push(row.size.x);
            character_widths.push(0.0);
        }

        let total_chars = character_lengths.len();

        if total_chars <= MAX_CHARS_PER_TEXT_RUN {
            let run_id = parent_id.with(row_index).with(0usize);
            ctx.register_accesskit_parent(run_id, parent_id);

            ctx.accesskit_node_builder(run_id, |builder| {
                builder.set_role(accesskit::Role::TextRun);
                builder.set_text_direction(accesskit::TextDirection::LeftToRight);
                // TODO(mwcampbell): Set more node fields for the row
                // once AccessKit adapters expose text formatting info.

                let rect = global_from_galley * row.rect_without_leading_space();
                builder.set_bounds(accesskit::Rect {
                    x0: rect.min.x.into(),
                    y0: rect.min.y.into(),
                    x1: rect.max.x.into(),
                    y1: rect.max.y.into(),
                });
                builder.set_value(value);
                builder.set_character_lengths(character_lengths);

                let pos_offset = character_positions.first().copied().unwrap_or(0.0);
                for p in &mut character_positions {
                    *p -= pos_offset;
                }
                builder.set_character_positions(character_positions);
                builder.set_character_widths(character_widths);

                let chunk_word_starts: Vec<u8> = word_starts.iter().map(|&ws| ws as u8).collect();
                builder.set_word_starts(chunk_word_starts);
            });
        } else {
            let num_chunks = total_chars.div_ceil(MAX_CHARS_PER_TEXT_RUN);
            let mut byte_offset = 0usize;

            for chunk_idx in 0..num_chunks {
                let char_start = chunk_idx * MAX_CHARS_PER_TEXT_RUN;
                let char_end = (char_start + MAX_CHARS_PER_TEXT_RUN).min(total_chars);

                let byte_start = byte_offset;
                let chunk_byte_len: usize = character_lengths[char_start..char_end]
                    .iter()
                    .map(|&l| l as usize)
                    .sum();
                let byte_end = byte_start + chunk_byte_len;
                byte_offset = byte_end;

                let run_id = parent_id.with(row_index).with(chunk_idx);
                ctx.register_accesskit_parent(run_id, parent_id);

                ctx.accesskit_node_builder(run_id, |builder| {
                    builder.set_role(accesskit::Role::TextRun);
                    builder.set_text_direction(accesskit::TextDirection::LeftToRight);
                    // TODO(mwcampbell): Set more node fields for the row
                    // once AccessKit adapters expose text formatting info.

                    if chunk_idx > 0 {
                        let prev_id = parent_id.with(row_index).with(chunk_idx - 1);
                        builder.set_previous_on_line(prev_id.accesskit_id());
                    }
                    if chunk_idx + 1 < num_chunks {
                        let next_id = parent_id.with(row_index).with(chunk_idx + 1);
                        builder.set_next_on_line(next_id.accesskit_id());
                    }

                    let row_rect = row.rect_without_leading_space();
                    let chunk_x0 = row.pos.x + character_positions[char_start];
                    let chunk_x1 = row.pos.x
                        + character_positions[char_end - 1]
                        + character_widths[char_end - 1];
                    let chunk_rect = emath::Rect::from_min_max(
                        emath::pos2(chunk_x0, row_rect.min.y),
                        emath::pos2(chunk_x1, row_rect.max.y),
                    );
                    let rect = global_from_galley * chunk_rect;
                    builder.set_bounds(accesskit::Rect {
                        x0: rect.min.x.into(),
                        y0: rect.min.y.into(),
                        x1: rect.max.x.into(),
                        y1: rect.max.y.into(),
                    });
                    builder.set_value(value[byte_start..byte_end].to_owned());
                    builder.set_character_lengths(character_lengths[char_start..char_end].to_vec());

                    let pos_offset = character_positions[char_start];
                    let chunk_positions: Vec<f32> = character_positions[char_start..char_end]
                        .iter()
                        .map(|&p| p - pos_offset)
                        .collect();
                    builder.set_character_positions(chunk_positions);
                    builder.set_character_widths(character_widths[char_start..char_end].to_vec());

                    let chunk_word_starts: Vec<u8> = word_starts
                        .iter()
                        .filter(|&&ws| ws >= char_start && ws < char_end)
                        .map(|&ws| (ws - char_start) as u8)
                        .collect();
                    builder.set_word_starts(chunk_word_starts);
                });
            }
        }

        prev_row_ended_with_newline = row.ends_with_newline;
    }
}