Deryks _dev

Ask egui what it knows

The editor reports the cursor's raw offset — or says there isn't one.

So far you've drawn the text box with ui.add(…), which hands back only whether it was clicked. TextEdit has a richer door: .show(ui)returns everything it learned while drawing. Three edits.

First — swap ui.add for .show and keep the result:

editor/src/main.rsin fn ui, the text box

            ui.add(
                egui::TextEdit::multiline(&mut self.text)
                    .font(egui::TextStyle::Monospace)
                    .desired_width(f32::INFINITY),
            );
            let output = egui::TextEdit::multiline(&mut self.text)
                .font(egui::TextStyle::Monospace)
                .desired_width(f32::INFINITY)
                .show(ui);

Second — report what came back, just above the labels you already have:

editor/src/main.rsin fn ui, under the text box

            let position = match output.cursor_range {
                Some(range) => format!("offset {}", range.primary.index.0),
                None => "no cursor".to_owned(),
            };
            ui.label(format!("{} bytes", self.text.len()));

Third — fold the position into the byte-count label. The status label below it is shown only so you can see where the change lands; leave that line alone.

editor/src/main.rsin fn ui, replacing the byte-count label

            ui.label(format!("{} bytes", self.text.len()));
            ui.label(format!("{position}  ·  {} bytes", self.text.len()));
            ui.label(&self.status);

The other enum

cursor_range is an Option<CCursorRange>, andOption is Result's sibling. Same idea — an enum with two variants, the compiler forcing you through both — but for absence rather than failure:

There genuinely might not be a cursor — click outside the text box and it loses focus, and there is nothing to report. Languages with null pointers express that by handing you a value that looks fine until you touch it. Rust makes you name the empty case before it will let you at the full one.

range.primary.index.0 — primary is the moving end of a selection (secondary is the anchor), and the .0unwraps a one-field wrapper type. Stage 2 explains why that wrapper exists; it turns out to be the most important thing on this page.

cargo run
→ click in the text: offset 34 · 61 bytes
→ click outside it: no cursor · 61 bytes

Turn one number into two

A real Ln / Col readout that tracks your cursor.

An offset is where the cursor is; a line and column is where it feels like it is. Converting means walking the text and counting newlines. Two edits.

First — a method, after save in your impl Editor block:

editor/src/main.rsin impl Editor, after save

    }

    /// Turn a character offset into a 1-based line and column.
    fn line_col(&self, char_index: usize) -> (usize, usize) {
        let mut line = 1;
        let mut column = 1;
        for ch in self.text.chars().take(char_index) {
            if ch == '\n' {
                line += 1;
                column = 1;
            } else {
                column += 1;
            }
        }
        (line, column)
    }
}

The return type (usize, usize) is a tuple — two values travelling together without inventing a struct for them. usize is the unsigned integer type used for sizes and indices; it's as wide as a pointer on your machine.

self.text.chars() is an iterator over characters, and.take(char_index) stops it after that many. So the loop walks exactly the text before the cursor, counting newlines. Lines and columns start at 1 because that's what every editor and compiler shows — including the src/main.rs:39:17 in the errors you've been reading.

Second — use it:

editor/src/main.rsin fn ui, the position match

            let position = match output.cursor_range {
                Some(range) => format!("offset {}", range.primary.index.0),
                Some(range) => {
                    let (line, column) = self.line_col(range.primary.index.0);
                    format!("Ln {line}, Col {column}")
                }
                None => "no cursor".to_owned(),
            };

let (line, column) = … is destructuring: the tuple comes back and is immediately taken apart into two named values. Same pattern-matching machinery as Some(range) on the line above, used for a happier purpose.

cargo run
→ move the cursor around: Ln 2, Col 5 · 61 bytes

The bug you can't see in English

Understand why char_index is not self.text[..i].

No code change in this stage — this one is about a mistake you haven't made yet, so that you don't. Put a non-English character in your scratch file:

printf 'let x = 1;\nlet café = 2;\nlet y = 3;\n' > editor/scratch.md
→ run, and click just after the é

Look at the two numbers you're now showing. That text is:

bytes = 37, chars = 36

Thirty-seven bytes, thirty-six characters. The é takes two bytes. Rust strings are UTF-8, where a character is one to four bytes depending on what it is — ASCII is one, accented Latin is two, most CJK is three, emoji are four.

So there are two numbers you could call "the position", and they disagree the moment text stops being English:

The silent version is bad. The loud version looks like this — and it's apanic, at runtime, on your user's machine:

thread 'main' panicked at src/main.rs:9:18:
end byte index 8 is not a char boundary; it is inside 'é' (bytes 7..9 of string)

This is why line_col takes self.text.chars() and never slices. It counts the same units egui counts, so the two can't drift apart.

Why the API made you write .0

Remember range.primary.index.0, and that odd .0. Here's how egui declares that field:

/// Character offset (NOT byte offset!).
pub index: CharIndex,

// …where CharIndex is:
pub struct CharIndex(pub usize);

It's a usize in a wrapper that exists purely to have a different name. That's a newtype, and the point is that a CharIndex won't compile where a byte index is expected, even though both are just numbers underneath. The capital-letters comment tells you the library authors have been bitten; the type makes sure you can't be, at least not by accident.

There's a third number this lesson is quietly ignoring: what the user sees as a column. A tab may render as eight spaces, and a family emoji is severalchar values that draw as one glyph. "Column" in a real editor means grapheme clusters, not chars. We'll take that on when we paint text ourselves.