guise/editor/

editor.rs

//! `Editor` — a multiline code editor (gpui entity).
//!
//! Renders an [`EditorModel`] with a line-number gutter, syntax highlighting
//! (a built-in [`Language`] tokenizer, or a whole-document
//! [`DocumentHighlighter`] such as the `treesitter` feature's adapter),
//! selection, caret, and the full macOS-convention keyboard map. Emits
//! [`EditorEvent::Change`] on every edit and [`EditorEvent::Run`] on
//! Cmd+Enter, so a host can execute the buffer (a query console, a REPL).
//!
//! ```ignore
//! let editor = cx.new(|cx| {
//!     Editor::new(cx)
//!         .language(Language::Rust)
//!         .rows(8)
//!         .value("fn main() {\n    println!(\"hi\");\n}")
//! });
//! cx.subscribe(&editor, |_this, _editor, event: &EditorEvent, _cx| {
//!     if let EditorEvent::Run(source) = event {
//!         // Cmd+Enter — run `source`
//!     }
//! })
//! .detach();
//! ```

use std::ops::Range;

use gpui::prelude::*;
use gpui::{
    canvas, div, point, px, App, Bounds, ClipboardItem, Context, Div, DragMoveEvent, Empty, Entity,
    EntityId, EventEmitter, FocusHandle, Font, Hsla, IntoElement, KeyDownEvent, MouseButton,
    MouseDownEvent, Pixels, Point, ScrollHandle, ShapedLine, SharedString, StyledText, TextRun,
    Window,
};

use super::cache::HighlightCache;
use super::diagnostic::{line_message, line_severity, Diagnostic};
use super::highlight::{token_color, DocumentHighlighter, Language, TokenKind};
use super::model::{EditorModel, Pos};
use crate::reactive::Signal;
use crate::theme::theme;

use crate::devtools::Probed;
/// The monospace family used for the buffer, gutter, and placeholder.
use crate::style::MONO_FAMILY;
/// Horizontal padding around the text content, in px.
const PAD_X: f32 = 10.0;
/// Vertical padding above and below the lines, in px.
const PAD_Y: f32 = 8.0;
/// Padding inside the gutter on each side of the line numbers, in px.
const GUTTER_PAD: f32 = 10.0;

/// Emitted as the user edits or asks to run the buffer.
#[derive(Debug, Clone)]
pub enum EditorEvent {
    /// The document changed. Carries the full new text.
    Change(String),
    /// Cmd+Enter. Carries the current text, for hosts that execute it.
    Run(String),
}

/// The drag payload for selection-by-mouse; tagged with the owning entity so
/// two editors in one window never react to each other's drags.
struct EditorDrag(EntityId);

/// Per-editor visual overrides. Unset fields fall back to the theme-derived
/// defaults, so an empty style changes nothing.
#[derive(Clone, Copy, Default)]
pub struct EditorStyle {
    /// Paint no frame border and no corner radius (an embedded strip).
    pub bare: bool,
    pub bg: Option<Hsla>,
    pub text: Option<Hsla>,
    pub caret: Option<Hsla>,
    pub selection: Option<Hsla>,
    pub active_line: Option<Hsla>,
    pub gutter_fg: Option<Hsla>,
    pub gutter_fg_active: Option<Hsla>,
    pub placeholder: Option<Hsla>,
}

/// A multiline code editor. Create with `cx.new(|cx| Editor::new(cx))`.
///
/// The text model is the unit-tested [`EditorModel`] (char-index cursor,
/// anchor selection, coalesced undo). Read-only editors still support
/// selection and copy — only mutations are blocked.
pub struct Editor {
    model: EditorModel,
    language: Language,
    /// Whole-document highlighter; overrides `language` while set.
    doc_highlighter: Option<Box<dyn DocumentHighlighter>>,
    /// Whether `doc_highlighter` must reparse before the next paint.
    doc_dirty: bool,
    /// Per-line tokens for the `language` path, revalidated each frame and
    /// re-tokenized only for lines that changed.
    hl_cache: HighlightCache,
    placeholder: SharedString,
    read_only: bool,
    line_numbers: bool,
    font_size: f32,
    rows: Option<usize>,
    token_palette: Option<[Hsla; 8]>,
    style: EditorStyle,
    highlights: Vec<(Pos, Pos, Hsla)>,
    diagnostics: Vec<Diagnostic>,
    focus: FocusHandle,
    scroll: ScrollHandle,
    hscroll: ScrollHandle,
    /// Window-space bounds of the text content, captured at prepaint. Mouse
    /// positions minus this origin give content coordinates directly (the
    /// captured origin already moves with both scroll axes).
    text_bounds: Bounds<Pixels>,
    /// Measured monospace cell advance ('0'), refreshed every render. Only a
    /// rough unit (gutter width, scroll margins) — never per-glyph math.
    cell_w: f32,
    /// Line height in px, refreshed every render.
    line_h: f32,
    /// The resolved mono font, refreshed every render so shaping for mouse
    /// math uses exactly the font the glyphs are painted with.
    mono_font: Font,
}

impl EventEmitter<EditorEvent> for Editor {}

impl Editor {
    pub fn new(cx: &mut Context<Self>) -> Self {
        Editor {
            model: EditorModel::new(""),
            language: Language::None,
            doc_highlighter: None,
            doc_dirty: true,
            hl_cache: HighlightCache::new(),
            placeholder: SharedString::default(),
            read_only: false,
            line_numbers: true,
            font_size: 13.0,
            rows: None,
            token_palette: None,
            style: EditorStyle::default(),
            highlights: Vec::new(),
            diagnostics: Vec::new(),
            focus: cx.focus_handle(),
            scroll: ScrollHandle::new(),
            hscroll: ScrollHandle::new(),
            text_bounds: Bounds::default(),
            cell_w: 13.0 * 0.6,
            line_h: 20.0,
            mono_font: gpui::font(MONO_FAMILY),
        }
    }

    // ---- builders ----

    /// Initial text (named like [`TextInput::value`](crate::input::TextInput::value);
    /// `text()` is the getter).
    pub fn value(mut self, text: &str) -> Self {
        self.model.set_text(text);
        self
    }

    /// Syntax highlighting language (default [`Language::None`]).
    pub fn language(mut self, language: Language) -> Self {
        self.language = language;
        self.hl_cache.clear();
        self
    }

    /// Highlight with a whole-document backend (a tree-sitter adapter)
    /// instead of the line-based `language` tokenizer. Takes precedence over
    /// [`language`](Self::language) while set.
    pub fn highlighter(mut self, highlighter: impl DocumentHighlighter + 'static) -> Self {
        self.doc_highlighter = Some(Box::new(highlighter));
        self.doc_dirty = true;
        self
    }

    /// Dimmed hint shown while the buffer is empty and unfocused.
    pub fn placeholder(mut self, placeholder: impl Into<SharedString>) -> Self {
        self.placeholder = placeholder.into();
        self
    }

    /// Block edits. Selection, copy, and Cmd+Enter still work.
    pub fn read_only(mut self, read_only: bool) -> Self {
        self.read_only = read_only;
        self
    }

    /// Show the line-number gutter (default true).
    pub fn line_numbers(mut self, show: bool) -> Self {
        self.line_numbers = show;
        self
    }

    /// Spaces per tab stop (default 4).
    pub fn tab_size(mut self, n: usize) -> Self {
        self.model.set_tab_size(n);
        self
    }

    /// Buffer font size in px (default 13.0).
    pub fn font_size(mut self, size: f32) -> Self {
        self.font_size = size;
        self
    }

    /// Minimum height, as a number of visible lines.
    pub fn rows(mut self, rows: usize) -> Self {
        self.rows = Some(rows);
        self
    }

    /// Override the syntax palette — one color per [`TokenKind`], in
    /// [`TokenKind::ALL`] order. Defaults to the theme mapping
    /// ([`token_color`]).
    pub fn token_colors(mut self, colors: [Hsla; 8]) -> Self {
        self.token_palette = Some(colors);
        self
    }

    /// Per-editor visual overrides (see [`EditorStyle`]).
    pub fn style(mut self, style: EditorStyle) -> Self {
        self.style = style;
        self
    }

    /// Replace the style at runtime (theme switches).
    pub fn set_style(&mut self, style: EditorStyle, cx: &mut Context<Self>) {
        self.style = style;
        cx.notify();
    }

    /// Switch the highlighting language at runtime (a file-type change).
    /// Ignored while a document highlighter is set.
    pub fn set_language(&mut self, language: Language, cx: &mut Context<Self>) {
        self.language = language;
        self.hl_cache.clear();
        cx.notify();
    }

    /// Install or replace the document highlighter at runtime; `None` falls
    /// back to the line-based `language` tokenizer.
    pub fn set_highlighter(
        &mut self,
        highlighter: Option<Box<dyn DocumentHighlighter>>,
        cx: &mut Context<Self>,
    ) {
        self.doc_highlighter = highlighter;
        self.doc_dirty = true;
        cx.notify();
    }

    /// Background rectangles painted under the text — search matches,
    /// occurrence highlights. Document-position ranges; multi-line ranges
    /// paint like selections.
    pub fn set_highlights(&mut self, highlights: Vec<(Pos, Pos, Hsla)>, cx: &mut Context<Self>) {
        self.highlights = highlights;
        cx.notify();
    }

    /// Attach diagnostics (compiler/linter/LSP output). Affected lines get a
    /// severity-colored gutter dot and range underline, and the active
    /// line's message shows in a strip under the buffer.
    pub fn set_diagnostics(&mut self, diagnostics: Vec<Diagnostic>, cx: &mut Context<Self>) {
        self.diagnostics = diagnostics;
        cx.notify();
    }

    pub fn clear_diagnostics(&mut self, cx: &mut Context<Self>) {
        if !self.diagnostics.is_empty() {
            self.diagnostics.clear();
            cx.notify();
        }
    }

    pub fn diagnostics(&self) -> &[Diagnostic] {
        &self.diagnostics
    }

    // ---- runtime API ----

    /// The current document text.
    pub fn text(&self) -> String {
        self.model.text()
    }

    /// Replace the document, resetting cursor, selection, and history.
    pub fn set_text(&mut self, value: &str, cx: &mut Context<Self>) {
        self.model.set_text(value);
        self.doc_dirty = true;
        cx.notify();
    }

    /// The editor's focus handle, so a host can focus it on open.
    pub fn focus_handle(&self) -> FocusHandle {
        self.focus.clone()
    }

    /// Read access to the underlying [`EditorModel`] — cursor, selection,
    /// lines — for hosts that build features over the buffer (completion,
    /// modal keymaps, search).
    pub fn model(&self) -> &EditorModel {
        &self.model
    }

    /// Mutate the [`EditorModel`] directly. Emits [`EditorEvent::Change`]
    /// when the text changed, keeps the caret visible, and repaints — the
    /// same bookkeeping every built-in edit goes through.
    pub fn edit<R>(
        &mut self,
        window: &mut Window,
        cx: &mut Context<Self>,
        f: impl FnOnce(&mut EditorModel) -> R,
    ) -> R {
        let before = self.model.text();
        let result = f(&mut self.model);
        let after = self.model.text();
        if after != before {
            self.doc_dirty = true;
            cx.emit(EditorEvent::Change(after));
        }
        self.ensure_cursor_visible(window);
        cx.notify();
        result
    }

    /// Window-space origin of the caret's cell — where a completion popup or
    /// search bar anchors. Tracks both scroll axes; meaningless before the
    /// first paint (returns the content origin).
    pub fn caret_origin(&self, window: &Window) -> Point<Pixels> {
        let cursor = self.model.cursor();
        let x = match self.model.line(cursor.line) {
            Some(line) => self.caret_x(line, cursor.col, window),
            None => 0.0,
        };
        point(
            self.text_bounds.origin.x + px(x),
            self.text_bounds.origin.y + px(cursor.line as f32 * self.line_h),
        )
    }

    /// The pixel height of one buffer line, as painted last frame.
    pub fn line_height(&self) -> f32 {
        self.line_h
    }

    /// Two-way bind this editor's text to a `Signal<String>`. The signal is
    /// the source of truth: the editor adopts its value now, edits write back
    /// through [`Signal::set_if_changed`], and signal writes replace the text.
    /// Equality guards on both directions prevent update loops.
    pub fn bind(entity: &Entity<Editor>, signal: &Signal<String>, cx: &mut App) {
        let initial = signal.get(cx);
        entity.update(cx, |this, cx| {
            if this.text() != initial {
                this.set_text(&initial, cx);
            }
        });
        let sink = signal.clone();
        cx.subscribe(entity, move |_editor, event: &EditorEvent, cx| {
            if let EditorEvent::Change(text) = event {
                sink.set_if_changed(cx, text.clone());
            }
        })
        .detach();
        // Weak handle: a strong clone would form a retain cycle with the
        // subscription above and leak both the editor and the signal.
        let editor = entity.downgrade();
        cx.observe(signal.entity(), move |observed, cx| {
            let value = observed.read(cx).clone();
            editor
                .update(cx, |this, cx| {
                    if this.text() != value {
                        this.set_text(&value, cx);
                    }
                })
                .ok();
        })
        .detach();
    }

    // ---- input handling ----

    fn on_key(&mut self, event: &KeyDownEvent, window: &mut Window, cx: &mut Context<Self>) {
        let ks = &event.keystroke;
        let m = ks.modifiers;
        let shift = m.shift;
        match ks.key.as_str() {
            "left" => {
                if m.platform {
                    self.model.home(shift);
                } else if m.alt {
                    self.model.word_left(shift);
                } else {
                    self.model.move_left(shift);
                }
                self.after_move(window, cx);
            }
            "right" => {
                if m.platform {
                    self.model.end(shift);
                } else if m.alt {
                    self.model.word_right(shift);
                } else {
                    self.model.move_right(shift);
                }
                self.after_move(window, cx);
            }
            "up" => {
                if m.platform {
                    self.model.doc_start(shift);
                } else {
                    self.model.move_up(shift);
                }
                self.after_move(window, cx);
            }
            "down" => {
                if m.platform {
                    self.model.doc_end(shift);
                } else {
                    self.model.move_down(shift);
                }
                self.after_move(window, cx);
            }
            "home" => {
                if m.platform {
                    self.model.doc_start(shift);
                } else {
                    self.model.home(shift);
                }
                self.after_move(window, cx);
            }
            "end" => {
                if m.platform {
                    self.model.doc_end(shift);
                } else {
                    self.model.end(shift);
                }
                self.after_move(window, cx);
            }
            "backspace" => {
                if self.read_only {
                    return;
                }
                let changed = if self.model.selection().is_some() {
                    self.model.delete_selection()
                } else if m.platform {
                    self.model.home(true);
                    self.model.delete_selection()
                } else if m.alt {
                    self.model.word_left(true);
                    self.model.delete_selection()
                } else {
                    self.model.backspace()
                };
                if changed {
                    self.after_edit(window, cx);
                } else {
                    cx.stop_propagation();
                }
            }
            "delete" => {
                if self.read_only {
                    return;
                }
                let changed = if self.model.selection().is_some() {
                    self.model.delete_selection()
                } else if m.platform {
                    self.model.end(true);
                    self.model.delete_selection()
                } else if m.alt {
                    self.model.word_right(true);
                    self.model.delete_selection()
                } else {
                    self.model.delete()
                };
                if changed {
                    self.after_edit(window, cx);
                } else {
                    cx.stop_propagation();
                }
            }
            "enter" if m.platform => {
                cx.emit(EditorEvent::Run(self.model.text()));
                cx.stop_propagation();
            }
            "enter" => {
                if self.read_only {
                    return;
                }
                self.model.newline();
                self.after_edit(window, cx);
            }
            "tab" => {
                // Cmd+Tab (and read-only Tab) bubbles so hosts keep focus moves.
                if m.platform || self.read_only {
                    return;
                }
                self.model.tab();
                self.after_edit(window, cx);
            }
            // Escape bubbles (dialogs close on it) but still drops the selection.
            "escape" => {
                if self.model.selection().is_some() {
                    self.model.clear_selection();
                    cx.notify();
                }
            }
            "a" if m.platform => {
                self.model.select_all();
                cx.notify();
                cx.stop_propagation();
            }
            "c" if m.platform => {
                if let Some(text) = self.model.copy() {
                    cx.write_to_clipboard(ClipboardItem::new_string(text));
                }
                cx.stop_propagation();
            }
            "x" if m.platform => {
                if self.read_only {
                    // Selection stays; degrade cut to copy.
                    if let Some(text) = self.model.copy() {
                        cx.write_to_clipboard(ClipboardItem::new_string(text));
                    }
                } else if let Some(text) = self.model.cut() {
                    cx.write_to_clipboard(ClipboardItem::new_string(text));
                    self.after_edit(window, cx);
                    return;
                }
                cx.stop_propagation();
            }
            "v" if m.platform => {
                if !self.read_only {
                    if let Some(text) = cx.read_from_clipboard().and_then(|item| item.text()) {
                        if !text.is_empty() {
                            self.model.insert(&text);
                            self.after_edit(window, cx);
                            return;
                        }
                    }
                }
                cx.stop_propagation();
            }
            "z" if m.platform => {
                if !self.read_only {
                    let changed = if m.shift {
                        self.model.redo()
                    } else {
                        self.model.undo()
                    };
                    if changed {
                        self.after_edit(window, cx);
                        return;
                    }
                }
                cx.stop_propagation();
            }
            _ => {
                // Printable input: never on Cmd/Ctrl chords; Option+key is
                // allowed so composed glyphs land (matches `input::apply_key`).
                if !self.read_only && !m.platform && !m.control {
                    if let Some(text) = ks.key_char.as_deref().filter(|t| !t.is_empty()) {
                        self.model.insert(text);
                        self.after_edit(window, cx);
                    }
                }
                // Everything else bubbles to the host.
            }
        }
    }

    fn on_mouse_down(&mut self, ev: &MouseDownEvent, window: &mut Window, cx: &mut Context<Self>) {
        window.focus(&self.focus);
        let (line, col) = self.hit(ev.position, window);
        match ev.click_count {
            2 => {
                self.model.move_to(line, col, false);
                self.model.select_word();
            }
            n if n > 2 => {
                self.model.move_to(line, col, false);
                self.model.select_line();
            }
            _ => self.model.move_to(line, col, ev.modifiers.shift),
        }
        cx.notify();
    }

    fn on_drag_move(
        &mut self,
        ev: &DragMoveEvent<EditorDrag>,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        if ev.drag(cx).0 != cx.entity_id() {
            return;
        }
        let (line, col) = self.hit(ev.event.position, window);
        self.model.move_to(line, col, true);
        self.ensure_cursor_visible(window);
        cx.notify();
    }

    /// Shape one line with the editor's mono font. The resulting layout maps
    /// char boundaries to painted x positions (and back), so mouse math, the
    /// caret, and selection agree with the glyphs `StyledText` actually paints
    /// — including double-width CJK/emoji fallback glyphs and literal tabs.
    fn shape(&self, line: &str, window: &Window) -> ShapedLine {
        let text = SharedString::from(line.to_string());
        let run = TextRun {
            len: text.len(),
            font: self.mono_font.clone(),
            color: Hsla::default(),
            background_color: None,
            underline: None,
            strikethrough: None,
        };
        window
            .text_system()
            .shape_line(text, px(self.font_size), &[run], None)
    }

    /// Window position -> (line, col): the line from the fixed row height,
    /// the column from the shaped line's closest char boundary. The model
    /// clamps out-of-range values.
    fn hit(&self, position: Point<Pixels>, window: &Window) -> (usize, usize) {
        let x = f32::from(position.x) - f32::from(self.text_bounds.origin.x);
        let y = f32::from(position.y) - f32::from(self.text_bounds.origin.y);
        let line = hit_line(y, self.line_h).min(self.model.line_count().saturating_sub(1));
        let Some(text) = self.model.line(line) else {
            return (line, 0);
        };
        let byte = self.shape(text, window).closest_index_for_x(px(x.max(0.0)));
        (line, col_for_byte(text, byte))
    }

    /// Painted x of the caret at char column `col` on `line`.
    fn caret_x(&self, line: &str, col: usize, window: &Window) -> f32 {
        f32::from(
            self.shape(line, window)
                .x_for_index(byte_for_col(line, col)),
        )
    }

    fn after_edit(&mut self, window: &mut Window, cx: &mut Context<Self>) {
        self.doc_dirty = true;
        cx.emit(EditorEvent::Change(self.model.text()));
        self.ensure_cursor_visible(window);
        cx.notify();
        cx.stop_propagation();
    }

    fn after_move(&mut self, window: &mut Window, cx: &mut Context<Self>) {
        self.ensure_cursor_visible(window);
        cx.notify();
        cx.stop_propagation();
    }

    /// Nudge both scroll axes so the caret (plus a padding margin) is inside
    /// the viewport. No-op before the first paint.
    fn ensure_cursor_visible(&mut self, window: &Window) {
        let cursor = self.model.cursor();
        let view_h = f32::from(self.scroll.bounds().size.height);
        if view_h > 0.0 {
            let top = cursor.line as f32 * self.line_h;
            let bottom = top + self.line_h + 2.0 * PAD_Y;
            let offset = self.scroll.offset();
            let y = scroll_adjust(f32::from(offset.y), view_h, top, bottom);
            if y != f32::from(offset.y) {
                self.scroll.set_offset(point(offset.x, px(y)));
            }
        }
        let view_w = f32::from(self.hscroll.bounds().size.width);
        if view_w > 0.0 {
            let left = match self.model.line(cursor.line) {
                Some(line) => self.caret_x(line, cursor.col, window),
                None => cursor.col as f32 * self.cell_w,
            };
            let right = left + self.cell_w + 2.0 * PAD_X;
            let offset = self.hscroll.offset();
            let x = scroll_adjust(f32::from(offset.x), view_w, left, right);
            if x != f32::from(offset.x) {
                self.hscroll.set_offset(point(px(x), offset.y));
            }
        }
    }
}

impl Render for Editor {
    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        let focused = self.focus.is_focused(window);

        let t = theme(cx);
        let style = self.style;
        let frame_border = if focused {
            t.primary().hsla()
        } else {
            t.border().hsla()
        };
        let edge = t.border().hsla();
        let bg = style.bg.unwrap_or_else(|| t.surface().hsla());
        let text_color = style.text.unwrap_or_else(|| t.text().hsla());
        let dimmed = style.placeholder.unwrap_or_else(|| t.dimmed().hsla());
        let caret_color = style.caret.unwrap_or_else(|| t.primary().hsla());
        let selection_bg = style.selection.unwrap_or_else(|| t.primary().alpha(0.25));
        let active_bg = style
            .active_line
            .unwrap_or_else(|| t.surface_hover().alpha(0.55));
        let gutter_fg = style.gutter_fg.unwrap_or_else(|| t.dimmed().alpha(0.7));
        let gutter_fg_active = style.gutter_fg_active.unwrap_or(text_color);
        let radius = t.radius(t.default_radius);
        let token_colors: [Hsla; 8] = self
            .token_palette
            .unwrap_or_else(|| TokenKind::ALL.map(|kind| token_color(kind, t)));

        // Resolve the mono font once per render and keep it on self: mouse
        // math shapes lines with the same font the glyphs are painted with.
        let font_size = self.font_size;
        let line_h = (font_size * 1.5).round();
        let font = Font {
            family: MONO_FAMILY.into(),
            ..window.text_style().font()
        };
        let cell_w = {
            let ts = window.text_system();
            let font_id = ts.resolve_font(&font);
            ts.ch_advance(font_id, px(font_size))
                .map(f32::from)
                .unwrap_or(font_size * 0.6)
        };
        self.line_h = line_h;
        self.cell_w = cell_w;
        self.mono_font = font.clone();

        let cursor = self.model.cursor();
        let selection = self.model.selection();
        let line_count = self.model.line_count();
        let show_placeholder = self.model.is_empty() && !focused && !self.placeholder.is_empty();
        let show_caret = focused && !self.read_only;

        let digits = line_count.to_string().len().max(2);
        let gutter_w = digits as f32 * cell_w + 2.0 * GUTTER_PAD;
        let mut max_line_w: f32 = 0.0;

        // Re-highlight only what changed, never per frame: the document
        // highlighter reparses on its dirty flag; the line cache revalidates
        // against the lines and re-tokenizes only the ones that moved.
        match &mut self.doc_highlighter {
            Some(doc) => {
                if self.doc_dirty {
                    let text = self.model.text();
                    doc.update(&text);
                    self.doc_dirty = false;
                }
            }
            None => {
                self.hl_cache.sync(&self.language, self.model.lines());
            }
        }

        let mut gutter_rows: Vec<Div> = Vec::with_capacity(line_count);
        let mut text_rows: Vec<Div> = Vec::with_capacity(line_count);
        for (i, line) in self.model.lines().iter().enumerate() {
            let is_active = i == cursor.line;

            if self.line_numbers {
                let mut gutter_row = div()
                    .relative()
                    .h(px(line_h))
                    .flex()
                    .items_center()
                    .justify_end()
                    .text_color(if is_active && focused {
                        gutter_fg_active
                    } else {
                        gutter_fg
                    })
                    .child(SharedString::from((i + 1).to_string()));
                if let Some(severity) = line_severity(&self.diagnostics, i) {
                    gutter_row = gutter_row.child(
                        div()
                            .absolute()
                            .left(px(1.0))
                            .top(px((line_h - 6.0) / 2.0))
                            .w(px(6.0))
                            .h(px(6.0))
                            .rounded_full()
                            .bg(severity.color(t)),
                    );
                }
                gutter_rows.push(gutter_row);
            }

            // Shaped once per line (cached across frames by gpui): painted
            // width, selection rects, and the caret all read real glyph
            // positions instead of assuming one uniform cell per char.
            let shaped = self.shape(line, window);
            max_line_w = max_line_w.max(f32::from(shaped.width));

            let mut row = div().relative().h(px(line_h)).w_full();
            if focused && is_active {
                row = row.bg(active_bg);
            }
            for (start, end, color) in &self.highlights {
                if let Some((s, e, newline)) = line_selection(*start, *end, i, line.chars().count())
                {
                    let sx = f32::from(shaped.x_for_index(byte_for_col(line, s)));
                    let ex = f32::from(shaped.x_for_index(byte_for_col(line, e)));
                    let w = (ex - sx) + if newline { cell_w } else { 0.0 };
                    row = row.child(
                        div()
                            .absolute()
                            .top_0()
                            .bottom_0()
                            .left(px(sx))
                            .w(px(w))
                            .bg(*color),
                    );
                }
            }
            if let Some((start, end)) = selection {
                if let Some((s, e, newline)) = line_selection(start, end, i, line.chars().count()) {
                    let sx = f32::from(shaped.x_for_index(byte_for_col(line, s)));
                    let ex = f32::from(shaped.x_for_index(byte_for_col(line, e)));
                    let w = (ex - sx) + if newline { cell_w } else { 0.0 };
                    row = row.child(
                        div()
                            .absolute()
                            .top_0()
                            .bottom_0()
                            .left(px(sx))
                            .w(px(w))
                            .bg(selection_bg),
                    );
                }
            }
            // Diagnostic underlines: a 2px severity-colored bar under the
            // char range (empty range = the whole line).
            for diag in self.diagnostics.iter().filter(|d| d.line == i) {
                let chars = line.chars().count();
                let (s, e) = if diag.cols.is_empty() || diag.cols.start >= chars {
                    (0, chars)
                } else {
                    (diag.cols.start, diag.cols.end.min(chars))
                };
                let sx = f32::from(shaped.x_for_index(byte_for_col(line, s)));
                let ex = f32::from(shaped.x_for_index(byte_for_col(line, e)));
                row = row.child(
                    div()
                        .absolute()
                        .bottom(px(1.0))
                        .left(px(sx))
                        .w(px((ex - sx).max(cell_w * 0.75)))
                        .h(px(2.0))
                        .rounded(px(1.0))
                        .bg(diag.severity.color(t)),
                );
            }
            let tokens = match &self.doc_highlighter {
                Some(doc) => doc.tokens(i),
                None => self.hl_cache.tokens(i),
            };
            if !line.is_empty() {
                let runs: Vec<TextRun> = spans(line.len(), tokens)
                    .into_iter()
                    .map(|(len, kind)| TextRun {
                        len,
                        font: font.clone(),
                        color: kind.map_or(text_color, |k| token_colors[k.index()]),
                        background_color: None,
                        underline: None,
                        strikethrough: None,
                    })
                    .collect();
                row = row.child(StyledText::new(SharedString::from(line.clone())).with_runs(runs));
            } else if i == 0 && show_placeholder {
                row = row.child(div().text_color(dimmed).child(self.placeholder.clone()));
            }
            if show_caret && is_active {
                let x = f32::from(shaped.x_for_index(byte_for_col(line, cursor.col)));
                row = row.child(
                    div()
                        .absolute()
                        .top_0()
                        .h(px(line_h))
                        .left(px((x - 1.0).max(0.0)))
                        .w(px(2.0))
                        .bg(caret_color),
                );
            }
            text_rows.push(row);
        }
        let content_w = max_line_w + cell_w;

        // Invisible bounds probe: its painted origin (which moves with both
        // scroll axes) is exactly where content cell (0, 0) is, so mouse
        // hit-testing is a subtraction.
        let entity = cx.entity();
        let probe = canvas(
            move |bounds, _window, cx| {
                entity.update(cx, |this, _| this.text_bounds = bounds);
            },
            |_, _, _, _| {},
        )
        .absolute()
        .size_full();

        let lines_col = div()
            .relative()
            .flex()
            .flex_col()
            .flex_grow()
            .min_w(px(content_w))
            .whitespace_nowrap()
            .child(probe)
            .children(text_rows);

        let text_area = div()
            .id("guise-editor-text")
            .flex_1()
            .overflow_x_scroll()
            .track_scroll(&self.hscroll)
            .px(px(PAD_X))
            .child(lines_col);

        let mut content_row = div().flex().items_start().w_full().py(px(PAD_Y));
        if self.line_numbers {
            content_row = content_row.child(
                div()
                    .flex()
                    .flex_col()
                    .flex_none()
                    .w(px(gutter_w))
                    .pr(px(GUTTER_PAD))
                    .border_r_1()
                    .border_color(edge)
                    .children(gutter_rows),
            );
        }
        content_row = content_row.child(text_area);

        let mut body = div()
            .id("guise-editor-body")
            .track_focus(&self.focus)
            .on_key_down(cx.listener(Self::on_key))
            .on_mouse_down(MouseButton::Left, cx.listener(Self::on_mouse_down))
            .on_drag(EditorDrag(cx.entity_id()), |_, _, _, cx| cx.new(|_| Empty))
            .on_drag_move(cx.listener(Self::on_drag_move))
            .overflow_y_scroll()
            .track_scroll(&self.scroll)
            .w_full()
            .max_h_full()
            .cursor_text()
            .child(content_row);
        if let Some(rows) = self.rows {
            body = body.min_h(px(rows as f32 * line_h + 2.0 * PAD_Y));
        }

        let mut frame = div().flex().flex_col().w_full().h_full();
        if !style.bare {
            frame = frame
                .rounded(px(radius))
                .border_1()
                .border_color(frame_border);
        }
        frame = frame
            .bg(bg)
            .overflow_hidden()
            .font_family(MONO_FAMILY)
            .text_size(px(font_size))
            .line_height(px(line_h))
            .text_color(text_color)
            .child(body);

        // The active line's diagnostic, in a strip under the buffer (no
        // hover needed, no hit-test interference with text selection).
        if let Some(diag) = line_message(&self.diagnostics, cursor.line) {
            let accent = diag.severity.color(t);
            frame = frame.child(
                div()
                    .flex()
                    .items_center()
                    .gap(px(6.0))
                    .px(px(PAD_X))
                    .py(px(3.0))
                    .border_t_1()
                    .border_color(edge)
                    .bg(Hsla { a: 0.06, ..accent })
                    .text_size(px(font_size - 2.0))
                    .text_color(dimmed)
                    .child(div().w(px(6.0)).h(px(6.0)).rounded_full().bg(accent))
                    .child(diag.message.clone()),
            );
        }
        frame.probe("Editor")
    }
}

// ---- pure geometry helpers (unit-tested) -----------------------------------

/// Cover `len` bytes with contiguous span lengths: token ranges keep their
/// kind, gaps get `None`. Clamps overlapping or out-of-range tokens so the
/// lengths always sum to exactly `len` (a gpui `StyledText` requirement).
fn spans(len: usize, tokens: &[(Range<usize>, TokenKind)]) -> Vec<(usize, Option<TokenKind>)> {
    let mut out = Vec::new();
    let mut at = 0;
    for (range, kind) in tokens {
        let start = range.start.max(at).min(len);
        let end = range.end.max(start).min(len);
        if start > at {
            out.push((start - at, None));
        }
        if end > start {
            out.push((end - start, Some(*kind)));
        }
        at = end.max(at);
    }
    if at < len {
        out.push((len - at, None));
    }
    out
}

/// The selected char-column range on `line` for a normalized selection
/// `(start, end)`, or `None` when the selection misses the line entirely.
/// The `bool` is whether the selection continues past this line's end (draw
/// the newline as one extra cell).
fn line_selection(
    start: Pos,
    end: Pos,
    line: usize,
    line_len: usize,
) -> Option<(usize, usize, bool)> {
    if line < start.line || line > end.line {
        return None;
    }
    let s = if line == start.line {
        start.col.min(line_len)
    } else {
        0
    };
    let e = if line == end.line {
        end.col.min(line_len)
    } else {
        line_len
    };
    let e = e.max(s);
    let newline = line < end.line;
    if e == s && !newline {
        return None;
    }
    Some((s, e, newline))
}

/// Content-space y -> line row, clamping negatives to zero. Rows share one
/// fixed height, so this stays uniform math; columns go through shaping.
fn hit_line(y: f32, line_h: f32) -> usize {
    (y / line_h).floor().max(0.0) as usize
}

/// Byte offset of char column `col` in `line`, clamped to the line end.
fn byte_for_col(line: &str, col: usize) -> usize {
    line.char_indices()
        .nth(col)
        .map(|(i, _)| i)
        .unwrap_or(line.len())
}

/// Char column of byte offset `byte` in `line`. Boundary-safe: offsets inside
/// a multi-byte char count as the column of that char.
fn col_for_byte(line: &str, byte: usize) -> usize {
    line.char_indices().take_while(|&(i, _)| i < byte).count()
}

/// Adjust a scroll offset (0 or negative, more negative = scrolled further)
/// so the content range `top..bottom` is inside a `view`-long viewport.
fn scroll_adjust(offset: f32, view: f32, top: f32, bottom: f32) -> f32 {
    let mut adjusted = offset;
    if bottom + adjusted > view {
        adjusted = view - bottom;
    }
    if top + adjusted < 0.0 {
        adjusted = -top;
    }
    adjusted
}

#[cfg(test)]
mod tests {
    use super::*;

    fn total(spans: &[(usize, Option<TokenKind>)]) -> usize {
        spans.iter().map(|(len, _)| len).sum()
    }

    #[test]
    fn spans_cover_the_line_exactly() {
        let tokens = vec![(2..5, TokenKind::Keyword), (7..9, TokenKind::Number)];
        let s = spans(10, &tokens);
        assert_eq!(
            s,
            vec![
                (2, None),
                (3, Some(TokenKind::Keyword)),
                (2, None),
                (2, Some(TokenKind::Number)),
                (1, None),
            ]
        );
        assert_eq!(total(&s), 10);
    }

    #[test]
    fn spans_with_no_tokens_is_one_gap() {
        assert_eq!(spans(4, &[]), vec![(4, None)]);
        assert!(spans(0, &[]).is_empty());
    }

    #[test]
    fn spans_clamp_overlap_and_overflow() {
        // Overlapping ranges never double-cover bytes...
        let tokens = vec![(0..6, TokenKind::Keyword), (4..8, TokenKind::Number)];
        let s = spans(10, &tokens);
        assert_eq!(total(&s), 10);
        // ...and ranges past the end clamp to it.
        let tokens = vec![(8..20, TokenKind::Comment)];
        let s = spans(10, &tokens);
        assert_eq!(s, vec![(8, None), (2, Some(TokenKind::Comment))]);
    }

    #[test]
    fn spans_token_flush_to_both_edges() {
        let tokens = vec![(0..10, TokenKind::Comment)];
        assert_eq!(spans(10, &tokens), vec![(10, Some(TokenKind::Comment))]);
    }

    fn at(line: usize, col: usize) -> Pos {
        Pos::new(line, col)
    }

    #[test]
    fn selection_on_a_single_line() {
        let sel = line_selection(at(1, 2), at(1, 5), 1, 8);
        assert_eq!(sel, Some((2, 5, false)));
        assert_eq!(line_selection(at(1, 2), at(1, 5), 0, 8), None);
        assert_eq!(line_selection(at(1, 2), at(1, 5), 2, 8), None);
    }

    #[test]
    fn selection_across_lines() {
        // First line: from start.col to the end, plus the newline cell.
        assert_eq!(line_selection(at(0, 3), at(2, 2), 0, 6), Some((3, 6, true)));
        // Middle line: everything, plus the newline cell.
        assert_eq!(line_selection(at(0, 3), at(2, 2), 1, 4), Some((0, 4, true)));
        // Last line: from col 0 to end.col.
        assert_eq!(
            line_selection(at(0, 3), at(2, 2), 2, 6),
            Some((0, 2, false))
        );
    }

    #[test]
    fn selection_on_an_empty_middle_line_shows_the_newline() {
        assert_eq!(line_selection(at(0, 0), at(2, 1), 1, 0), Some((0, 0, true)));
    }

    #[test]
    fn selection_cols_clamp_to_line_len() {
        assert_eq!(line_selection(at(0, 10), at(0, 20), 0, 5), None); // both past end
        assert_eq!(
            line_selection(at(0, 2), at(0, 20), 0, 5),
            Some((2, 5, false))
        );
    }

    #[test]
    fn hit_line_maps_and_clamps() {
        assert_eq!(hit_line(0.0, 20.0), 0);
        assert_eq!(hit_line(45.0, 20.0), 2);
        assert_eq!(hit_line(-10.0, 20.0), 0); // padding clicks above the text
    }

    #[test]
    fn byte_for_col_handles_multibyte_chars() {
        assert_eq!(byte_for_col("abc", 0), 0);
        assert_eq!(byte_for_col("abc", 2), 2);
        assert_eq!(byte_for_col("abc", 9), 3); // clamps to the line end
                                               // "日本語abc": each CJK char is 3 bytes.
        assert_eq!(byte_for_col("日本語abc", 1), 3);
        assert_eq!(byte_for_col("日本語abc", 3), 9);
        assert_eq!(byte_for_col("日本語abc", 4), 10);
    }

    #[test]
    fn col_for_byte_inverts_byte_for_col() {
        let line = "日本語abc";
        for col in 0..=6 {
            assert_eq!(col_for_byte(line, byte_for_col(line, col)), col);
        }
        assert_eq!(col_for_byte(line, 999), 6); // past the end
        assert_eq!(col_for_byte("", 0), 0);
    }

    #[test]
    fn scroll_adjust_reveals_the_target() {
        // Already visible: unchanged.
        assert_eq!(scroll_adjust(-10.0, 100.0, 20.0, 40.0), -10.0);
        // Above the viewport: scroll up to the top edge.
        assert_eq!(scroll_adjust(-50.0, 100.0, 20.0, 40.0), -20.0);
        // Below the viewport: scroll down to the bottom edge.
        assert_eq!(scroll_adjust(0.0, 100.0, 150.0, 170.0), -70.0);
        // Taller than the viewport: the top wins.
        assert_eq!(scroll_adjust(0.0, 50.0, 100.0, 200.0), -100.0);
    }
}