1use super::{
   2    display_map::{BlockContext, ToDisplayPoint},
   3    Anchor, DisplayPoint, Editor, EditorMode, EditorSnapshot, SelectPhase, SoftWrap, ToPoint,
   4    MAX_LINE_LEN,
   5};
   6use crate::{
   7    display_map::{BlockStyle, DisplaySnapshot, FoldStatus, TransformBlock},
   8    editor_settings::ShowScrollbars,
   9    git::{diff_hunk_to_display, DisplayDiffHunk},
  10    hover_popover::{
  11        hide_hover, hover_at, HOVER_POPOVER_GAP, MIN_POPOVER_CHARACTER_WIDTH,
  12        MIN_POPOVER_LINE_HEIGHT,
  13    },
  14    link_go_to_definition::{
  15        go_to_fetched_definition, go_to_fetched_type_definition, update_go_to_definition_link,
  16    },
  17    mouse_context_menu, EditorSettings, EditorStyle, GutterHover, UnfoldAt,
  18};
  19use clock::ReplicaId;
  20use collections::{BTreeMap, HashMap};
  21use git::diff::DiffHunkStatus;
  22use gpui::{
  23    color::Color,
  24    elements::*,
  25    fonts::{HighlightStyle, TextStyle, Underline},
  26    geometry::{
  27        rect::RectF,
  28        vector::{vec2f, Vector2F},
  29        PathBuilder,
  30    },
  31    json::{self, ToJson},
  32    platform::{CursorStyle, Modifiers, MouseButton, MouseButtonEvent, MouseMovedEvent},
  33    text_layout::{self, Line, RunStyle, TextLayoutCache},
  34    AnyElement, Axis, Border, CursorRegion, Element, EventContext, FontCache, LayoutContext,
  35    MouseRegion, Quad, SceneBuilder, SizeConstraint, ViewContext, WindowContext,
  36};
  37use itertools::Itertools;
  38use json::json;
  39use language::{
  40    language_settings::ShowWhitespaceSetting, Bias, CursorShape, DiagnosticSeverity, OffsetUtf16,
  41    Selection,
  42};
  43use project::ProjectPath;
  44use smallvec::SmallVec;
  45use std::{
  46    borrow::Cow,
  47    cmp::{self, Ordering},
  48    fmt::Write,
  49    iter,
  50    ops::Range,
  51    sync::Arc,
  52};
  53use text::Point;
  54use workspace::{item::Item, GitGutterSetting, WorkspaceSettings};
  55
  56enum FoldMarkers {}
  57
  58struct SelectionLayout {
  59    head: DisplayPoint,
  60    cursor_shape: CursorShape,
  61    range: Range<DisplayPoint>,
  62}
  63
  64impl SelectionLayout {
  65    fn new<T: ToPoint + ToDisplayPoint + Clone>(
  66        selection: Selection<T>,
  67        line_mode: bool,
  68        cursor_shape: CursorShape,
  69        map: &DisplaySnapshot,
  70    ) -> Self {
  71        if line_mode {
  72            let selection = selection.map(|p| p.to_point(&map.buffer_snapshot));
  73            let point_range = map.expand_to_line(selection.range());
  74            Self {
  75                head: selection.head().to_display_point(map),
  76                cursor_shape,
  77                range: point_range.start.to_display_point(map)
  78                    ..point_range.end.to_display_point(map),
  79            }
  80        } else {
  81            let selection = selection.map(|p| p.to_display_point(map));
  82            Self {
  83                head: selection.head(),
  84                cursor_shape,
  85                range: selection.range(),
  86            }
  87        }
  88    }
  89}
  90
  91#[derive(Clone)]
  92pub struct EditorElement {
  93    style: Arc<EditorStyle>,
  94}
  95
  96impl EditorElement {
  97    pub fn new(style: EditorStyle) -> Self {
  98        Self {
  99            style: Arc::new(style),
 100        }
 101    }
 102
 103    fn attach_mouse_handlers(
 104        scene: &mut SceneBuilder,
 105        position_map: &Arc<PositionMap>,
 106        has_popovers: bool,
 107        visible_bounds: RectF,
 108        text_bounds: RectF,
 109        gutter_bounds: RectF,
 110        bounds: RectF,
 111        cx: &mut ViewContext<Editor>,
 112    ) {
 113        enum EditorElementMouseHandlers {}
 114        scene.push_mouse_region(
 115            MouseRegion::new::<EditorElementMouseHandlers>(
 116                cx.view_id(),
 117                cx.view_id(),
 118                visible_bounds,
 119            )
 120            .on_down(MouseButton::Left, {
 121                let position_map = position_map.clone();
 122                move |event, editor, cx| {
 123                    if !Self::mouse_down(
 124                        editor,
 125                        event.platform_event,
 126                        position_map.as_ref(),
 127                        text_bounds,
 128                        gutter_bounds,
 129                        cx,
 130                    ) {
 131                        cx.propagate_event();
 132                    }
 133                }
 134            })
 135            .on_down(MouseButton::Right, {
 136                let position_map = position_map.clone();
 137                move |event, editor, cx| {
 138                    if !Self::mouse_right_down(
 139                        editor,
 140                        event.position,
 141                        position_map.as_ref(),
 142                        text_bounds,
 143                        cx,
 144                    ) {
 145                        cx.propagate_event();
 146                    }
 147                }
 148            })
 149            .on_up(MouseButton::Left, {
 150                let position_map = position_map.clone();
 151                move |event, editor, cx| {
 152                    if !Self::mouse_up(
 153                        editor,
 154                        event.position,
 155                        event.cmd,
 156                        event.shift,
 157                        position_map.as_ref(),
 158                        text_bounds,
 159                        cx,
 160                    ) {
 161                        cx.propagate_event()
 162                    }
 163                }
 164            })
 165            .on_drag(MouseButton::Left, {
 166                let position_map = position_map.clone();
 167                move |event, editor, cx| {
 168                    if !Self::mouse_dragged(
 169                        editor,
 170                        event.platform_event,
 171                        position_map.as_ref(),
 172                        text_bounds,
 173                        cx,
 174                    ) {
 175                        cx.propagate_event()
 176                    }
 177                }
 178            })
 179            .on_move({
 180                let position_map = position_map.clone();
 181                move |event, editor, cx| {
 182                    if !Self::mouse_moved(
 183                        editor,
 184                        event.platform_event,
 185                        &position_map,
 186                        text_bounds,
 187                        cx,
 188                    ) {
 189                        cx.propagate_event()
 190                    }
 191                }
 192            })
 193            .on_move_out(move |_, editor: &mut Editor, cx| {
 194                if has_popovers {
 195                    hide_hover(editor, cx);
 196                }
 197            })
 198            .on_scroll({
 199                let position_map = position_map.clone();
 200                move |event, editor, cx| {
 201                    if !Self::scroll(
 202                        editor,
 203                        event.position,
 204                        *event.delta.raw(),
 205                        event.delta.precise(),
 206                        &position_map,
 207                        bounds,
 208                        cx,
 209                    ) {
 210                        cx.propagate_event()
 211                    }
 212                }
 213            }),
 214        );
 215
 216        enum GutterHandlers {}
 217        scene.push_mouse_region(
 218            MouseRegion::new::<GutterHandlers>(cx.view_id(), cx.view_id() + 1, gutter_bounds)
 219                .on_hover(|hover, editor: &mut Editor, cx| {
 220                    editor.gutter_hover(
 221                        &GutterHover {
 222                            hovered: hover.started,
 223                        },
 224                        cx,
 225                    );
 226                }),
 227        )
 228    }
 229
 230    fn mouse_down(
 231        editor: &mut Editor,
 232        MouseButtonEvent {
 233            position,
 234            modifiers:
 235                Modifiers {
 236                    shift,
 237                    ctrl,
 238                    alt,
 239                    cmd,
 240                    ..
 241                },
 242            mut click_count,
 243            ..
 244        }: MouseButtonEvent,
 245        position_map: &PositionMap,
 246        text_bounds: RectF,
 247        gutter_bounds: RectF,
 248        cx: &mut EventContext<Editor>,
 249    ) -> bool {
 250        if gutter_bounds.contains_point(position) {
 251            click_count = 3; // Simulate triple-click when clicking the gutter to select lines
 252        } else if !text_bounds.contains_point(position) {
 253            return false;
 254        }
 255
 256        let (position, target_position) = position_map.point_for_position(text_bounds, position);
 257
 258        if shift && alt {
 259            editor.select(
 260                SelectPhase::BeginColumnar {
 261                    position,
 262                    goal_column: target_position.column(),
 263                },
 264                cx,
 265            );
 266        } else if shift && !ctrl && !alt && !cmd {
 267            editor.select(
 268                SelectPhase::Extend {
 269                    position,
 270                    click_count,
 271                },
 272                cx,
 273            );
 274        } else {
 275            editor.select(
 276                SelectPhase::Begin {
 277                    position,
 278                    add: alt,
 279                    click_count,
 280                },
 281                cx,
 282            );
 283        }
 284
 285        true
 286    }
 287
 288    fn mouse_right_down(
 289        editor: &mut Editor,
 290        position: Vector2F,
 291        position_map: &PositionMap,
 292        text_bounds: RectF,
 293        cx: &mut EventContext<Editor>,
 294    ) -> bool {
 295        if !text_bounds.contains_point(position) {
 296            return false;
 297        }
 298
 299        let (point, _) = position_map.point_for_position(text_bounds, position);
 300        mouse_context_menu::deploy_context_menu(editor, position, point, cx);
 301        true
 302    }
 303
 304    fn mouse_up(
 305        editor: &mut Editor,
 306        position: Vector2F,
 307        cmd: bool,
 308        shift: bool,
 309        position_map: &PositionMap,
 310        text_bounds: RectF,
 311        cx: &mut EventContext<Editor>,
 312    ) -> bool {
 313        let end_selection = editor.has_pending_selection();
 314        let pending_nonempty_selections = editor.has_pending_nonempty_selection();
 315
 316        if end_selection {
 317            editor.select(SelectPhase::End, cx);
 318        }
 319
 320        if !pending_nonempty_selections && cmd && text_bounds.contains_point(position) {
 321            let (point, target_point) = position_map.point_for_position(text_bounds, position);
 322
 323            if point == target_point {
 324                if shift {
 325                    go_to_fetched_type_definition(editor, point, cx);
 326                } else {
 327                    go_to_fetched_definition(editor, point, cx);
 328                }
 329
 330                return true;
 331            }
 332        }
 333
 334        end_selection
 335    }
 336
 337    fn mouse_dragged(
 338        editor: &mut Editor,
 339        MouseMovedEvent {
 340            modifiers: Modifiers { cmd, shift, .. },
 341            position,
 342            ..
 343        }: MouseMovedEvent,
 344        position_map: &PositionMap,
 345        text_bounds: RectF,
 346        cx: &mut EventContext<Editor>,
 347    ) -> bool {
 348        // This will be handled more correctly once https://github.com/zed-industries/zed/issues/1218 is completed
 349        // Don't trigger hover popover if mouse is hovering over context menu
 350        let point = if text_bounds.contains_point(position) {
 351            let (point, target_point) = position_map.point_for_position(text_bounds, position);
 352            if point == target_point {
 353                Some(point)
 354            } else {
 355                None
 356            }
 357        } else {
 358            None
 359        };
 360
 361        update_go_to_definition_link(editor, point, cmd, shift, cx);
 362
 363        if editor.has_pending_selection() {
 364            let mut scroll_delta = Vector2F::zero();
 365
 366            let vertical_margin = position_map.line_height.min(text_bounds.height() / 3.0);
 367            let top = text_bounds.origin_y() + vertical_margin;
 368            let bottom = text_bounds.lower_left().y() - vertical_margin;
 369            if position.y() < top {
 370                scroll_delta.set_y(-scale_vertical_mouse_autoscroll_delta(top - position.y()))
 371            }
 372            if position.y() > bottom {
 373                scroll_delta.set_y(scale_vertical_mouse_autoscroll_delta(position.y() - bottom))
 374            }
 375
 376            let horizontal_margin = position_map.line_height.min(text_bounds.width() / 3.0);
 377            let left = text_bounds.origin_x() + horizontal_margin;
 378            let right = text_bounds.upper_right().x() - horizontal_margin;
 379            if position.x() < left {
 380                scroll_delta.set_x(-scale_horizontal_mouse_autoscroll_delta(
 381                    left - position.x(),
 382                ))
 383            }
 384            if position.x() > right {
 385                scroll_delta.set_x(scale_horizontal_mouse_autoscroll_delta(
 386                    position.x() - right,
 387                ))
 388            }
 389
 390            let (position, target_position) =
 391                position_map.point_for_position(text_bounds, position);
 392
 393            editor.select(
 394                SelectPhase::Update {
 395                    position,
 396                    goal_column: target_position.column(),
 397                    scroll_position: (position_map.snapshot.scroll_position() + scroll_delta)
 398                        .clamp(Vector2F::zero(), position_map.scroll_max),
 399                },
 400                cx,
 401            );
 402            hover_at(editor, point, cx);
 403            true
 404        } else {
 405            hover_at(editor, point, cx);
 406            false
 407        }
 408    }
 409
 410    fn mouse_moved(
 411        editor: &mut Editor,
 412        MouseMovedEvent {
 413            modifiers: Modifiers { shift, cmd, .. },
 414            position,
 415            ..
 416        }: MouseMovedEvent,
 417        position_map: &PositionMap,
 418        text_bounds: RectF,
 419        cx: &mut ViewContext<Editor>,
 420    ) -> bool {
 421        // This will be handled more correctly once https://github.com/zed-industries/zed/issues/1218 is completed
 422        // Don't trigger hover popover if mouse is hovering over context menu
 423        let point = position_to_display_point(position, text_bounds, position_map);
 424
 425        update_go_to_definition_link(editor, point, cmd, shift, cx);
 426        hover_at(editor, point, cx);
 427
 428        true
 429    }
 430
 431    fn scroll(
 432        editor: &mut Editor,
 433        position: Vector2F,
 434        mut delta: Vector2F,
 435        precise: bool,
 436        position_map: &PositionMap,
 437        bounds: RectF,
 438        cx: &mut ViewContext<Editor>,
 439    ) -> bool {
 440        if !bounds.contains_point(position) {
 441            return false;
 442        }
 443
 444        let line_height = position_map.line_height;
 445        let max_glyph_width = position_map.em_width;
 446
 447        let axis = if precise {
 448            //Trackpad
 449            position_map.snapshot.ongoing_scroll.filter(&mut delta)
 450        } else {
 451            //Not trackpad
 452            delta *= vec2f(max_glyph_width, line_height);
 453            None //Resets ongoing scroll
 454        };
 455
 456        let scroll_position = position_map.snapshot.scroll_position();
 457        let x = (scroll_position.x() * max_glyph_width - delta.x()) / max_glyph_width;
 458        let y = (scroll_position.y() * line_height - delta.y()) / line_height;
 459        let scroll_position = vec2f(x, y).clamp(Vector2F::zero(), position_map.scroll_max);
 460        editor.scroll(scroll_position, axis, cx);
 461
 462        true
 463    }
 464
 465    fn paint_background(
 466        &self,
 467        scene: &mut SceneBuilder,
 468        gutter_bounds: RectF,
 469        text_bounds: RectF,
 470        layout: &LayoutState,
 471    ) {
 472        let bounds = gutter_bounds.union_rect(text_bounds);
 473        let scroll_top =
 474            layout.position_map.snapshot.scroll_position().y() * layout.position_map.line_height;
 475        scene.push_quad(Quad {
 476            bounds: gutter_bounds,
 477            background: Some(self.style.gutter_background),
 478            border: Border::new(0., Color::transparent_black()),
 479            corner_radius: 0.,
 480        });
 481        scene.push_quad(Quad {
 482            bounds: text_bounds,
 483            background: Some(self.style.background),
 484            border: Border::new(0., Color::transparent_black()),
 485            corner_radius: 0.,
 486        });
 487
 488        if let EditorMode::Full = layout.mode {
 489            let mut active_rows = layout.active_rows.iter().peekable();
 490            while let Some((start_row, contains_non_empty_selection)) = active_rows.next() {
 491                let mut end_row = *start_row;
 492                while active_rows.peek().map_or(false, |r| {
 493                    *r.0 == end_row + 1 && r.1 == contains_non_empty_selection
 494                }) {
 495                    active_rows.next().unwrap();
 496                    end_row += 1;
 497                }
 498
 499                if !contains_non_empty_selection {
 500                    let origin = vec2f(
 501                        bounds.origin_x(),
 502                        bounds.origin_y() + (layout.position_map.line_height * *start_row as f32)
 503                            - scroll_top,
 504                    );
 505                    let size = vec2f(
 506                        bounds.width(),
 507                        layout.position_map.line_height * (end_row - start_row + 1) as f32,
 508                    );
 509                    scene.push_quad(Quad {
 510                        bounds: RectF::new(origin, size),
 511                        background: Some(self.style.active_line_background),
 512                        border: Border::default(),
 513                        corner_radius: 0.,
 514                    });
 515                }
 516            }
 517
 518            if let Some(highlighted_rows) = &layout.highlighted_rows {
 519                let origin = vec2f(
 520                    bounds.origin_x(),
 521                    bounds.origin_y()
 522                        + (layout.position_map.line_height * highlighted_rows.start as f32)
 523                        - scroll_top,
 524                );
 525                let size = vec2f(
 526                    bounds.width(),
 527                    layout.position_map.line_height * highlighted_rows.len() as f32,
 528                );
 529                scene.push_quad(Quad {
 530                    bounds: RectF::new(origin, size),
 531                    background: Some(self.style.highlighted_line_background),
 532                    border: Border::default(),
 533                    corner_radius: 0.,
 534                });
 535            }
 536        }
 537    }
 538
 539    fn paint_gutter(
 540        &mut self,
 541        scene: &mut SceneBuilder,
 542        bounds: RectF,
 543        visible_bounds: RectF,
 544        layout: &mut LayoutState,
 545        editor: &mut Editor,
 546        cx: &mut ViewContext<Editor>,
 547    ) {
 548        let line_height = layout.position_map.line_height;
 549
 550        let scroll_position = layout.position_map.snapshot.scroll_position();
 551        let scroll_top = scroll_position.y() * line_height;
 552
 553        let show_gutter = matches!(
 554            settings::get::<WorkspaceSettings>(cx)
 555                .git
 556                .git_gutter
 557                .unwrap_or_default(),
 558            GitGutterSetting::TrackedFiles
 559        );
 560
 561        if show_gutter {
 562            Self::paint_diff_hunks(scene, bounds, layout, cx);
 563        }
 564
 565        for (ix, line) in layout.line_number_layouts.iter().enumerate() {
 566            if let Some(line) = line {
 567                let line_origin = bounds.origin()
 568                    + vec2f(
 569                        bounds.width() - line.width() - layout.gutter_padding,
 570                        ix as f32 * line_height - (scroll_top % line_height),
 571                    );
 572
 573                line.paint(scene, line_origin, visible_bounds, line_height, cx);
 574            }
 575        }
 576
 577        for (ix, fold_indicator) in layout.fold_indicators.iter_mut().enumerate() {
 578            if let Some(indicator) = fold_indicator.as_mut() {
 579                let position = vec2f(
 580                    bounds.width() - layout.gutter_padding,
 581                    ix as f32 * line_height - (scroll_top % line_height),
 582                );
 583                let centering_offset = vec2f(
 584                    (layout.gutter_padding + layout.gutter_margin - indicator.size().x()) / 2.,
 585                    (line_height - indicator.size().y()) / 2.,
 586                );
 587
 588                let indicator_origin = bounds.origin() + position + centering_offset;
 589
 590                indicator.paint(scene, indicator_origin, visible_bounds, editor, cx);
 591            }
 592        }
 593
 594        if let Some((row, indicator)) = layout.code_actions_indicator.as_mut() {
 595            let mut x = 0.;
 596            let mut y = *row as f32 * line_height - scroll_top;
 597            x += ((layout.gutter_padding + layout.gutter_margin) - indicator.size().x()) / 2.;
 598            y += (line_height - indicator.size().y()) / 2.;
 599            indicator.paint(
 600                scene,
 601                bounds.origin() + vec2f(x, y),
 602                visible_bounds,
 603                editor,
 604                cx,
 605            );
 606        }
 607    }
 608
 609    fn paint_diff_hunks(
 610        scene: &mut SceneBuilder,
 611        bounds: RectF,
 612        layout: &mut LayoutState,
 613        cx: &mut ViewContext<Editor>,
 614    ) {
 615        let diff_style = &theme::current(cx).editor.diff.clone();
 616        let line_height = layout.position_map.line_height;
 617
 618        let scroll_position = layout.position_map.snapshot.scroll_position();
 619        let scroll_top = scroll_position.y() * line_height;
 620
 621        for hunk in &layout.display_hunks {
 622            let (display_row_range, status) = match hunk {
 623                //TODO: This rendering is entirely a horrible hack
 624                &DisplayDiffHunk::Folded { display_row: row } => {
 625                    let start_y = row as f32 * line_height - scroll_top;
 626                    let end_y = start_y + line_height;
 627
 628                    let width = diff_style.removed_width_em * line_height;
 629                    let highlight_origin = bounds.origin() + vec2f(-width, start_y);
 630                    let highlight_size = vec2f(width * 2., end_y - start_y);
 631                    let highlight_bounds = RectF::new(highlight_origin, highlight_size);
 632
 633                    scene.push_quad(Quad {
 634                        bounds: highlight_bounds,
 635                        background: Some(diff_style.modified),
 636                        border: Border::new(0., Color::transparent_black()),
 637                        corner_radius: 1. * line_height,
 638                    });
 639
 640                    continue;
 641                }
 642
 643                DisplayDiffHunk::Unfolded {
 644                    display_row_range,
 645                    status,
 646                } => (display_row_range, status),
 647            };
 648
 649            let color = match status {
 650                DiffHunkStatus::Added => diff_style.inserted,
 651                DiffHunkStatus::Modified => diff_style.modified,
 652
 653                //TODO: This rendering is entirely a horrible hack
 654                DiffHunkStatus::Removed => {
 655                    let row = display_row_range.start;
 656
 657                    let offset = line_height / 2.;
 658                    let start_y = row as f32 * line_height - offset - scroll_top;
 659                    let end_y = start_y + line_height;
 660
 661                    let width = diff_style.removed_width_em * line_height;
 662                    let highlight_origin = bounds.origin() + vec2f(-width, start_y);
 663                    let highlight_size = vec2f(width * 2., end_y - start_y);
 664                    let highlight_bounds = RectF::new(highlight_origin, highlight_size);
 665
 666                    scene.push_quad(Quad {
 667                        bounds: highlight_bounds,
 668                        background: Some(diff_style.deleted),
 669                        border: Border::new(0., Color::transparent_black()),
 670                        corner_radius: 1. * line_height,
 671                    });
 672
 673                    continue;
 674                }
 675            };
 676
 677            let start_row = display_row_range.start;
 678            let end_row = display_row_range.end;
 679
 680            let start_y = start_row as f32 * line_height - scroll_top;
 681            let end_y = end_row as f32 * line_height - scroll_top;
 682
 683            let width = diff_style.width_em * line_height;
 684            let highlight_origin = bounds.origin() + vec2f(-width, start_y);
 685            let highlight_size = vec2f(width * 2., end_y - start_y);
 686            let highlight_bounds = RectF::new(highlight_origin, highlight_size);
 687
 688            scene.push_quad(Quad {
 689                bounds: highlight_bounds,
 690                background: Some(color),
 691                border: Border::new(0., Color::transparent_black()),
 692                corner_radius: diff_style.corner_radius * line_height,
 693            });
 694        }
 695    }
 696
 697    fn paint_text(
 698        &mut self,
 699        scene: &mut SceneBuilder,
 700        bounds: RectF,
 701        visible_bounds: RectF,
 702        layout: &mut LayoutState,
 703        editor: &mut Editor,
 704        cx: &mut ViewContext<Editor>,
 705    ) {
 706        let style = &self.style;
 707        let local_replica_id = editor.replica_id(cx);
 708        let scroll_position = layout.position_map.snapshot.scroll_position();
 709        let start_row = layout.visible_display_row_range.start;
 710        let scroll_top = scroll_position.y() * layout.position_map.line_height;
 711        let max_glyph_width = layout.position_map.em_width;
 712        let scroll_left = scroll_position.x() * max_glyph_width;
 713        let content_origin = bounds.origin() + vec2f(layout.gutter_margin, 0.);
 714        let line_end_overshoot = 0.15 * layout.position_map.line_height;
 715        let whitespace_setting = editor.buffer.read(cx).settings_at(0, cx).show_whitespaces;
 716
 717        scene.push_layer(Some(bounds));
 718
 719        scene.push_cursor_region(CursorRegion {
 720            bounds,
 721            style: if !editor.link_go_to_definition_state.definitions.is_empty() {
 722                CursorStyle::PointingHand
 723            } else {
 724                CursorStyle::IBeam
 725            },
 726        });
 727
 728        let fold_corner_radius =
 729            self.style.folds.ellipses.corner_radius_factor * layout.position_map.line_height;
 730        for (id, range, color) in layout.fold_ranges.iter() {
 731            self.paint_highlighted_range(
 732                scene,
 733                range.clone(),
 734                *color,
 735                fold_corner_radius,
 736                fold_corner_radius * 2.,
 737                layout,
 738                content_origin,
 739                scroll_top,
 740                scroll_left,
 741                bounds,
 742            );
 743
 744            for bound in range_to_bounds(
 745                &range,
 746                content_origin,
 747                scroll_left,
 748                scroll_top,
 749                &layout.visible_display_row_range,
 750                line_end_overshoot,
 751                &layout.position_map,
 752            ) {
 753                scene.push_cursor_region(CursorRegion {
 754                    bounds: bound,
 755                    style: CursorStyle::PointingHand,
 756                });
 757
 758                let display_row = range.start.row();
 759
 760                let buffer_row = DisplayPoint::new(display_row, 0)
 761                    .to_point(&layout.position_map.snapshot.display_snapshot)
 762                    .row;
 763
 764                scene.push_mouse_region(
 765                    MouseRegion::new::<FoldMarkers>(cx.view_id(), *id as usize, bound)
 766                        .on_click(MouseButton::Left, move |_, editor: &mut Editor, cx| {
 767                            editor.unfold_at(&UnfoldAt { buffer_row }, cx)
 768                        })
 769                        .with_notify_on_hover(true)
 770                        .with_notify_on_click(true),
 771                )
 772            }
 773        }
 774
 775        for (range, color) in &layout.highlighted_ranges {
 776            self.paint_highlighted_range(
 777                scene,
 778                range.clone(),
 779                *color,
 780                0.,
 781                line_end_overshoot,
 782                layout,
 783                content_origin,
 784                scroll_top,
 785                scroll_left,
 786                bounds,
 787            );
 788        }
 789
 790        let mut cursors = SmallVec::<[Cursor; 32]>::new();
 791        let corner_radius = 0.15 * layout.position_map.line_height;
 792        let mut invisible_display_ranges = SmallVec::<[Range<DisplayPoint>; 32]>::new();
 793
 794        for (replica_id, selections) in &layout.selections {
 795            let replica_id = *replica_id;
 796            let selection_style = style.replica_selection_style(replica_id);
 797
 798            for selection in selections {
 799                if !selection.range.is_empty()
 800                    && (replica_id == local_replica_id
 801                        || Some(replica_id) == editor.leader_replica_id)
 802                {
 803                    invisible_display_ranges.push(selection.range.clone());
 804                }
 805                self.paint_highlighted_range(
 806                    scene,
 807                    selection.range.clone(),
 808                    selection_style.selection,
 809                    corner_radius,
 810                    corner_radius * 2.,
 811                    layout,
 812                    content_origin,
 813                    scroll_top,
 814                    scroll_left,
 815                    bounds,
 816                );
 817
 818                if editor.show_local_cursors(cx) || replica_id != local_replica_id {
 819                    let cursor_position = selection.head;
 820                    if layout
 821                        .visible_display_row_range
 822                        .contains(&cursor_position.row())
 823                    {
 824                        let cursor_row_layout = &layout.position_map.line_layouts
 825                            [(cursor_position.row() - start_row) as usize]
 826                            .line;
 827                        let cursor_column = cursor_position.column() as usize;
 828
 829                        let cursor_character_x = cursor_row_layout.x_for_index(cursor_column);
 830                        let mut block_width =
 831                            cursor_row_layout.x_for_index(cursor_column + 1) - cursor_character_x;
 832                        if block_width == 0.0 {
 833                            block_width = layout.position_map.em_width;
 834                        }
 835                        let block_text = if let CursorShape::Block = selection.cursor_shape {
 836                            layout
 837                                .position_map
 838                                .snapshot
 839                                .chars_at(cursor_position)
 840                                .next()
 841                                .and_then(|(character, _)| {
 842                                    let font_id =
 843                                        cursor_row_layout.font_for_index(cursor_column)?;
 844                                    let text = character.to_string();
 845
 846                                    Some(cx.text_layout_cache().layout_str(
 847                                        &text,
 848                                        cursor_row_layout.font_size(),
 849                                        &[(
 850                                            text.len(),
 851                                            RunStyle {
 852                                                font_id,
 853                                                color: style.background,
 854                                                underline: Default::default(),
 855                                            },
 856                                        )],
 857                                    ))
 858                                })
 859                        } else {
 860                            None
 861                        };
 862
 863                        let x = cursor_character_x - scroll_left;
 864                        let y = cursor_position.row() as f32 * layout.position_map.line_height
 865                            - scroll_top;
 866                        cursors.push(Cursor {
 867                            color: selection_style.cursor,
 868                            block_width,
 869                            origin: vec2f(x, y),
 870                            line_height: layout.position_map.line_height,
 871                            shape: selection.cursor_shape,
 872                            block_text,
 873                        });
 874                    }
 875                }
 876            }
 877        }
 878
 879        if let Some(visible_text_bounds) = bounds.intersection(visible_bounds) {
 880            for (ix, line_with_invisibles) in layout.position_map.line_layouts.iter().enumerate() {
 881                let row = start_row + ix as u32;
 882                line_with_invisibles.draw(
 883                    layout,
 884                    row,
 885                    scroll_top,
 886                    scene,
 887                    content_origin,
 888                    scroll_left,
 889                    visible_text_bounds,
 890                    whitespace_setting,
 891                    &invisible_display_ranges,
 892                    visible_bounds,
 893                    cx,
 894                )
 895            }
 896        }
 897
 898        scene.paint_layer(Some(bounds), |scene| {
 899            for cursor in cursors {
 900                cursor.paint(scene, content_origin, cx);
 901            }
 902        });
 903
 904        if let Some((position, context_menu)) = layout.context_menu.as_mut() {
 905            scene.push_stacking_context(None, None);
 906            let cursor_row_layout =
 907                &layout.position_map.line_layouts[(position.row() - start_row) as usize].line;
 908            let x = cursor_row_layout.x_for_index(position.column() as usize) - scroll_left;
 909            let y = (position.row() + 1) as f32 * layout.position_map.line_height - scroll_top;
 910            let mut list_origin = content_origin + vec2f(x, y);
 911            let list_width = context_menu.size().x();
 912            let list_height = context_menu.size().y();
 913
 914            // Snap the right edge of the list to the right edge of the window if
 915            // its horizontal bounds overflow.
 916            if list_origin.x() + list_width > cx.window_size().x() {
 917                list_origin.set_x((cx.window_size().x() - list_width).max(0.));
 918            }
 919
 920            if list_origin.y() + list_height > bounds.max_y() {
 921                list_origin.set_y(list_origin.y() - layout.position_map.line_height - list_height);
 922            }
 923
 924            context_menu.paint(
 925                scene,
 926                list_origin,
 927                RectF::from_points(Vector2F::zero(), vec2f(f32::MAX, f32::MAX)), // Let content bleed outside of editor
 928                editor,
 929                cx,
 930            );
 931
 932            scene.pop_stacking_context();
 933        }
 934
 935        if let Some((position, hover_popovers)) = layout.hover_popovers.as_mut() {
 936            scene.push_stacking_context(None, None);
 937
 938            // This is safe because we check on layout whether the required row is available
 939            let hovered_row_layout =
 940                &layout.position_map.line_layouts[(position.row() - start_row) as usize].line;
 941
 942            // Minimum required size: Take the first popover, and add 1.5 times the minimum popover
 943            // height. This is the size we will use to decide whether to render popovers above or below
 944            // the hovered line.
 945            let first_size = hover_popovers[0].size();
 946            let height_to_reserve = first_size.y()
 947                + 1.5 * MIN_POPOVER_LINE_HEIGHT as f32 * layout.position_map.line_height;
 948
 949            // Compute Hovered Point
 950            let x = hovered_row_layout.x_for_index(position.column() as usize) - scroll_left;
 951            let y = position.row() as f32 * layout.position_map.line_height - scroll_top;
 952            let hovered_point = content_origin + vec2f(x, y);
 953
 954            if hovered_point.y() - height_to_reserve > 0.0 {
 955                // There is enough space above. Render popovers above the hovered point
 956                let mut current_y = hovered_point.y();
 957                for hover_popover in hover_popovers {
 958                    let size = hover_popover.size();
 959                    let mut popover_origin = vec2f(hovered_point.x(), current_y - size.y());
 960
 961                    let x_out_of_bounds = bounds.max_x() - (popover_origin.x() + size.x());
 962                    if x_out_of_bounds < 0.0 {
 963                        popover_origin.set_x(popover_origin.x() + x_out_of_bounds);
 964                    }
 965
 966                    hover_popover.paint(
 967                        scene,
 968                        popover_origin,
 969                        RectF::from_points(Vector2F::zero(), vec2f(f32::MAX, f32::MAX)), // Let content bleed outside of editor
 970                        editor,
 971                        cx,
 972                    );
 973
 974                    current_y = popover_origin.y() - HOVER_POPOVER_GAP;
 975                }
 976            } else {
 977                // There is not enough space above. Render popovers below the hovered point
 978                let mut current_y = hovered_point.y() + layout.position_map.line_height;
 979                for hover_popover in hover_popovers {
 980                    let size = hover_popover.size();
 981                    let mut popover_origin = vec2f(hovered_point.x(), current_y);
 982
 983                    let x_out_of_bounds = bounds.max_x() - (popover_origin.x() + size.x());
 984                    if x_out_of_bounds < 0.0 {
 985                        popover_origin.set_x(popover_origin.x() + x_out_of_bounds);
 986                    }
 987
 988                    hover_popover.paint(
 989                        scene,
 990                        popover_origin,
 991                        RectF::from_points(Vector2F::zero(), vec2f(f32::MAX, f32::MAX)), // Let content bleed outside of editor
 992                        editor,
 993                        cx,
 994                    );
 995
 996                    current_y = popover_origin.y() + size.y() + HOVER_POPOVER_GAP;
 997                }
 998            }
 999
1000            scene.pop_stacking_context();
1001        }
1002
1003        scene.pop_layer();
1004    }
1005
1006    fn paint_scrollbar(
1007        &mut self,
1008        scene: &mut SceneBuilder,
1009        bounds: RectF,
1010        layout: &mut LayoutState,
1011        cx: &mut ViewContext<Editor>,
1012    ) {
1013        enum ScrollbarMouseHandlers {}
1014        if layout.mode != EditorMode::Full {
1015            return;
1016        }
1017
1018        let style = &self.style.theme.scrollbar;
1019
1020        let top = bounds.min_y();
1021        let bottom = bounds.max_y();
1022        let right = bounds.max_x();
1023        let left = right - style.width;
1024        let row_range = &layout.scrollbar_row_range;
1025        let max_row = layout.max_row as f32 + (row_range.end - row_range.start);
1026
1027        let mut height = bounds.height();
1028        let mut first_row_y_offset = 0.0;
1029
1030        // Impose a minimum height on the scrollbar thumb
1031        let row_height = height / max_row;
1032        let min_thumb_height =
1033            style.min_height_factor * cx.font_cache.line_height(self.style.text.font_size);
1034        let thumb_height = (row_range.end - row_range.start) * row_height;
1035        if thumb_height < min_thumb_height {
1036            first_row_y_offset = (min_thumb_height - thumb_height) / 2.0;
1037            height -= min_thumb_height - thumb_height;
1038        }
1039
1040        let y_for_row = |row: f32| -> f32 { top + first_row_y_offset + row * row_height };
1041
1042        let thumb_top = y_for_row(row_range.start) - first_row_y_offset;
1043        let thumb_bottom = y_for_row(row_range.end) + first_row_y_offset;
1044        let track_bounds = RectF::from_points(vec2f(left, top), vec2f(right, bottom));
1045        let thumb_bounds = RectF::from_points(vec2f(left, thumb_top), vec2f(right, thumb_bottom));
1046
1047        if layout.show_scrollbars {
1048            scene.push_quad(Quad {
1049                bounds: track_bounds,
1050                border: style.track.border,
1051                background: style.track.background_color,
1052                ..Default::default()
1053            });
1054
1055            if layout.is_singleton {
1056                let diff_style = theme::current(cx).editor.diff.clone();
1057                for hunk in layout
1058                    .position_map
1059                    .snapshot
1060                    .buffer_snapshot
1061                    .git_diff_hunks_in_range(0..(max_row.floor() as u32))
1062                {
1063                    let start_display = Point::new(hunk.buffer_range.start, 0)
1064                        .to_display_point(&layout.position_map.snapshot.display_snapshot);
1065                    let end_display = Point::new(hunk.buffer_range.end, 0)
1066                        .to_display_point(&layout.position_map.snapshot.display_snapshot);
1067                    let start_y = y_for_row(start_display.row() as f32);
1068                    let mut end_y = if hunk.buffer_range.start == hunk.buffer_range.end {
1069                        y_for_row((end_display.row() + 1) as f32)
1070                    } else {
1071                        y_for_row((end_display.row()) as f32)
1072                    };
1073
1074                    if end_y - start_y < 1. {
1075                        end_y = start_y + 1.;
1076                    }
1077                    let bounds = RectF::from_points(vec2f(left, start_y), vec2f(right, end_y));
1078
1079                    let color = match hunk.status() {
1080                        DiffHunkStatus::Added => diff_style.inserted,
1081                        DiffHunkStatus::Modified => diff_style.modified,
1082                        DiffHunkStatus::Removed => diff_style.deleted,
1083                    };
1084
1085                    let border = Border {
1086                        width: 1.,
1087                        color: style.thumb.border.color,
1088                        overlay: false,
1089                        top: false,
1090                        right: true,
1091                        bottom: false,
1092                        left: true,
1093                    };
1094
1095                    scene.push_quad(Quad {
1096                        bounds,
1097                        background: Some(color),
1098                        border,
1099                        corner_radius: style.thumb.corner_radius,
1100                    })
1101                }
1102            }
1103
1104            scene.push_quad(Quad {
1105                bounds: thumb_bounds,
1106                border: style.thumb.border,
1107                background: style.thumb.background_color,
1108                corner_radius: style.thumb.corner_radius,
1109            });
1110        }
1111
1112        scene.push_cursor_region(CursorRegion {
1113            bounds: track_bounds,
1114            style: CursorStyle::Arrow,
1115        });
1116        scene.push_mouse_region(
1117            MouseRegion::new::<ScrollbarMouseHandlers>(cx.view_id(), cx.view_id(), track_bounds)
1118                .on_move(move |_, editor: &mut Editor, cx| {
1119                    editor.scroll_manager.show_scrollbar(cx);
1120                })
1121                .on_down(MouseButton::Left, {
1122                    let row_range = row_range.clone();
1123                    move |event, editor: &mut Editor, cx| {
1124                        let y = event.position.y();
1125                        if y < thumb_top || thumb_bottom < y {
1126                            let center_row = ((y - top) * max_row as f32 / height).round() as u32;
1127                            let top_row = center_row
1128                                .saturating_sub((row_range.end - row_range.start) as u32 / 2);
1129                            let mut position = editor.scroll_position(cx);
1130                            position.set_y(top_row as f32);
1131                            editor.set_scroll_position(position, cx);
1132                        } else {
1133                            editor.scroll_manager.show_scrollbar(cx);
1134                        }
1135                    }
1136                })
1137                .on_drag(MouseButton::Left, {
1138                    move |event, editor: &mut Editor, cx| {
1139                        let y = event.prev_mouse_position.y();
1140                        let new_y = event.position.y();
1141                        if thumb_top < y && y < thumb_bottom {
1142                            let mut position = editor.scroll_position(cx);
1143                            position.set_y(position.y() + (new_y - y) * (max_row as f32) / height);
1144                            if position.y() < 0.0 {
1145                                position.set_y(0.);
1146                            }
1147                            editor.set_scroll_position(position, cx);
1148                        }
1149                    }
1150                }),
1151        );
1152    }
1153
1154    #[allow(clippy::too_many_arguments)]
1155    fn paint_highlighted_range(
1156        &self,
1157        scene: &mut SceneBuilder,
1158        range: Range<DisplayPoint>,
1159        color: Color,
1160        corner_radius: f32,
1161        line_end_overshoot: f32,
1162        layout: &LayoutState,
1163        content_origin: Vector2F,
1164        scroll_top: f32,
1165        scroll_left: f32,
1166        bounds: RectF,
1167    ) {
1168        let start_row = layout.visible_display_row_range.start;
1169        let end_row = layout.visible_display_row_range.end;
1170        if range.start != range.end {
1171            let row_range = if range.end.column() == 0 {
1172                cmp::max(range.start.row(), start_row)..cmp::min(range.end.row(), end_row)
1173            } else {
1174                cmp::max(range.start.row(), start_row)..cmp::min(range.end.row() + 1, end_row)
1175            };
1176
1177            let highlighted_range = HighlightedRange {
1178                color,
1179                line_height: layout.position_map.line_height,
1180                corner_radius,
1181                start_y: content_origin.y()
1182                    + row_range.start as f32 * layout.position_map.line_height
1183                    - scroll_top,
1184                lines: row_range
1185                    .into_iter()
1186                    .map(|row| {
1187                        let line_layout =
1188                            &layout.position_map.line_layouts[(row - start_row) as usize].line;
1189                        HighlightedRangeLine {
1190                            start_x: if row == range.start.row() {
1191                                content_origin.x()
1192                                    + line_layout.x_for_index(range.start.column() as usize)
1193                                    - scroll_left
1194                            } else {
1195                                content_origin.x() - scroll_left
1196                            },
1197                            end_x: if row == range.end.row() {
1198                                content_origin.x()
1199                                    + line_layout.x_for_index(range.end.column() as usize)
1200                                    - scroll_left
1201                            } else {
1202                                content_origin.x() + line_layout.width() + line_end_overshoot
1203                                    - scroll_left
1204                            },
1205                        }
1206                    })
1207                    .collect(),
1208            };
1209
1210            highlighted_range.paint(bounds, scene);
1211        }
1212    }
1213
1214    fn paint_blocks(
1215        &mut self,
1216        scene: &mut SceneBuilder,
1217        bounds: RectF,
1218        visible_bounds: RectF,
1219        layout: &mut LayoutState,
1220        editor: &mut Editor,
1221        cx: &mut ViewContext<Editor>,
1222    ) {
1223        let scroll_position = layout.position_map.snapshot.scroll_position();
1224        let scroll_left = scroll_position.x() * layout.position_map.em_width;
1225        let scroll_top = scroll_position.y() * layout.position_map.line_height;
1226
1227        for block in &mut layout.blocks {
1228            let mut origin = bounds.origin()
1229                + vec2f(
1230                    0.,
1231                    block.row as f32 * layout.position_map.line_height - scroll_top,
1232                );
1233            if !matches!(block.style, BlockStyle::Sticky) {
1234                origin += vec2f(-scroll_left, 0.);
1235            }
1236            block
1237                .element
1238                .paint(scene, origin, visible_bounds, editor, cx);
1239        }
1240    }
1241
1242    fn max_line_number_width(&self, snapshot: &EditorSnapshot, cx: &ViewContext<Editor>) -> f32 {
1243        let digit_count = (snapshot.max_buffer_row() as f32).log10().floor() as usize + 1;
1244        let style = &self.style;
1245
1246        cx.text_layout_cache()
1247            .layout_str(
1248                "1".repeat(digit_count).as_str(),
1249                style.text.font_size,
1250                &[(
1251                    digit_count,
1252                    RunStyle {
1253                        font_id: style.text.font_id,
1254                        color: Color::black(),
1255                        underline: Default::default(),
1256                    },
1257                )],
1258            )
1259            .width()
1260    }
1261
1262    //Folds contained in a hunk are ignored apart from shrinking visual size
1263    //If a fold contains any hunks then that fold line is marked as modified
1264    fn layout_git_gutters(
1265        &self,
1266        display_rows: Range<u32>,
1267        snapshot: &EditorSnapshot,
1268    ) -> Vec<DisplayDiffHunk> {
1269        let buffer_snapshot = &snapshot.buffer_snapshot;
1270
1271        let buffer_start_row = DisplayPoint::new(display_rows.start, 0)
1272            .to_point(snapshot)
1273            .row;
1274        let buffer_end_row = DisplayPoint::new(display_rows.end, 0)
1275            .to_point(snapshot)
1276            .row;
1277
1278        buffer_snapshot
1279            .git_diff_hunks_in_range(buffer_start_row..buffer_end_row)
1280            .map(|hunk| diff_hunk_to_display(hunk, snapshot))
1281            .dedup()
1282            .collect()
1283    }
1284
1285    fn layout_line_numbers(
1286        &self,
1287        rows: Range<u32>,
1288        active_rows: &BTreeMap<u32, bool>,
1289        is_singleton: bool,
1290        snapshot: &EditorSnapshot,
1291        cx: &ViewContext<Editor>,
1292    ) -> (
1293        Vec<Option<text_layout::Line>>,
1294        Vec<Option<(FoldStatus, BufferRow, bool)>>,
1295    ) {
1296        let style = &self.style;
1297        let include_line_numbers = snapshot.mode == EditorMode::Full;
1298        let mut line_number_layouts = Vec::with_capacity(rows.len());
1299        let mut fold_statuses = Vec::with_capacity(rows.len());
1300        let mut line_number = String::new();
1301        for (ix, row) in snapshot
1302            .buffer_rows(rows.start)
1303            .take((rows.end - rows.start) as usize)
1304            .enumerate()
1305        {
1306            let display_row = rows.start + ix as u32;
1307            let (active, color) = if active_rows.contains_key(&display_row) {
1308                (true, style.line_number_active)
1309            } else {
1310                (false, style.line_number)
1311            };
1312            if let Some(buffer_row) = row {
1313                if include_line_numbers {
1314                    line_number.clear();
1315                    write!(&mut line_number, "{}", buffer_row + 1).unwrap();
1316                    line_number_layouts.push(Some(cx.text_layout_cache().layout_str(
1317                        &line_number,
1318                        style.text.font_size,
1319                        &[(
1320                            line_number.len(),
1321                            RunStyle {
1322                                font_id: style.text.font_id,
1323                                color,
1324                                underline: Default::default(),
1325                            },
1326                        )],
1327                    )));
1328                    fold_statuses.push(
1329                        is_singleton
1330                            .then(|| {
1331                                snapshot
1332                                    .fold_for_line(buffer_row)
1333                                    .map(|fold_status| (fold_status, buffer_row, active))
1334                            })
1335                            .flatten(),
1336                    )
1337                }
1338            } else {
1339                fold_statuses.push(None);
1340                line_number_layouts.push(None);
1341            }
1342        }
1343
1344        (line_number_layouts, fold_statuses)
1345    }
1346
1347    fn layout_lines(
1348        &mut self,
1349        rows: Range<u32>,
1350        line_number_layouts: &[Option<Line>],
1351        snapshot: &EditorSnapshot,
1352        cx: &ViewContext<Editor>,
1353    ) -> Vec<LineWithInvisibles> {
1354        if rows.start >= rows.end {
1355            return Vec::new();
1356        }
1357
1358        // When the editor is empty and unfocused, then show the placeholder.
1359        if snapshot.is_empty() {
1360            let placeholder_style = self
1361                .style
1362                .placeholder_text
1363                .as_ref()
1364                .unwrap_or(&self.style.text);
1365            let placeholder_text = snapshot.placeholder_text();
1366            let placeholder_lines = placeholder_text
1367                .as_ref()
1368                .map_or("", AsRef::as_ref)
1369                .split('\n')
1370                .skip(rows.start as usize)
1371                .chain(iter::repeat(""))
1372                .take(rows.len());
1373            placeholder_lines
1374                .map(|line| {
1375                    cx.text_layout_cache().layout_str(
1376                        line,
1377                        placeholder_style.font_size,
1378                        &[(
1379                            line.len(),
1380                            RunStyle {
1381                                font_id: placeholder_style.font_id,
1382                                color: placeholder_style.color,
1383                                underline: Default::default(),
1384                            },
1385                        )],
1386                    )
1387                })
1388                .map(|line| LineWithInvisibles {
1389                    line,
1390                    invisibles: Vec::new(),
1391                })
1392                .collect()
1393        } else {
1394            let style = &self.style;
1395            let chunks = snapshot
1396                .chunks(rows.clone(), true, Some(style.theme.suggestion))
1397                .map(|chunk| {
1398                    let mut highlight_style = chunk
1399                        .syntax_highlight_id
1400                        .and_then(|id| id.style(&style.syntax));
1401
1402                    if let Some(chunk_highlight) = chunk.highlight_style {
1403                        if let Some(highlight_style) = highlight_style.as_mut() {
1404                            highlight_style.highlight(chunk_highlight);
1405                        } else {
1406                            highlight_style = Some(chunk_highlight);
1407                        }
1408                    }
1409
1410                    let mut diagnostic_highlight = HighlightStyle::default();
1411
1412                    if chunk.is_unnecessary {
1413                        diagnostic_highlight.fade_out = Some(style.unnecessary_code_fade);
1414                    }
1415
1416                    if let Some(severity) = chunk.diagnostic_severity {
1417                        // Omit underlines for HINT/INFO diagnostics on 'unnecessary' code.
1418                        if severity <= DiagnosticSeverity::WARNING || !chunk.is_unnecessary {
1419                            let diagnostic_style = super::diagnostic_style(severity, true, style);
1420                            diagnostic_highlight.underline = Some(Underline {
1421                                color: Some(diagnostic_style.message.text.color),
1422                                thickness: 1.0.into(),
1423                                squiggly: true,
1424                            });
1425                        }
1426                    }
1427
1428                    if let Some(highlight_style) = highlight_style.as_mut() {
1429                        highlight_style.highlight(diagnostic_highlight);
1430                    } else {
1431                        highlight_style = Some(diagnostic_highlight);
1432                    }
1433
1434                    HighlightedChunk {
1435                        chunk: chunk.text,
1436                        style: highlight_style,
1437                        is_tab: chunk.is_tab,
1438                    }
1439                });
1440
1441            LineWithInvisibles::from_chunks(
1442                chunks,
1443                &style.text,
1444                cx.text_layout_cache(),
1445                cx.font_cache(),
1446                MAX_LINE_LEN,
1447                rows.len() as usize,
1448                line_number_layouts,
1449                snapshot.mode,
1450            )
1451        }
1452    }
1453
1454    #[allow(clippy::too_many_arguments)]
1455    fn layout_blocks(
1456        &mut self,
1457        rows: Range<u32>,
1458        snapshot: &EditorSnapshot,
1459        editor_width: f32,
1460        scroll_width: f32,
1461        gutter_padding: f32,
1462        gutter_width: f32,
1463        em_width: f32,
1464        text_x: f32,
1465        line_height: f32,
1466        style: &EditorStyle,
1467        line_layouts: &[LineWithInvisibles],
1468        include_root: bool,
1469        editor: &mut Editor,
1470        cx: &mut LayoutContext<Editor>,
1471    ) -> (f32, Vec<BlockLayout>) {
1472        let tooltip_style = theme::current(cx).tooltip.clone();
1473        let scroll_x = snapshot.scroll_anchor.offset.x();
1474        let (fixed_blocks, non_fixed_blocks) = snapshot
1475            .blocks_in_range(rows.clone())
1476            .partition::<Vec<_>, _>(|(_, block)| match block {
1477                TransformBlock::ExcerptHeader { .. } => false,
1478                TransformBlock::Custom(block) => block.style() == BlockStyle::Fixed,
1479            });
1480        let mut render_block = |block: &TransformBlock, width: f32| {
1481            let mut element = match block {
1482                TransformBlock::Custom(block) => {
1483                    let align_to = block
1484                        .position()
1485                        .to_point(&snapshot.buffer_snapshot)
1486                        .to_display_point(snapshot);
1487                    let anchor_x = text_x
1488                        + if rows.contains(&align_to.row()) {
1489                            line_layouts[(align_to.row() - rows.start) as usize]
1490                                .line
1491                                .x_for_index(align_to.column() as usize)
1492                        } else {
1493                            layout_line(align_to.row(), snapshot, style, cx.text_layout_cache())
1494                                .x_for_index(align_to.column() as usize)
1495                        };
1496
1497                    block.render(&mut BlockContext {
1498                        view_context: cx,
1499                        anchor_x,
1500                        gutter_padding,
1501                        line_height,
1502                        scroll_x,
1503                        gutter_width,
1504                        em_width,
1505                    })
1506                }
1507                TransformBlock::ExcerptHeader {
1508                    id,
1509                    buffer,
1510                    range,
1511                    starts_new_buffer,
1512                    ..
1513                } => {
1514                    let id = *id;
1515                    let jump_icon = project::File::from_dyn(buffer.file()).map(|file| {
1516                        let jump_path = ProjectPath {
1517                            worktree_id: file.worktree_id(cx),
1518                            path: file.path.clone(),
1519                        };
1520                        let jump_anchor = range
1521                            .primary
1522                            .as_ref()
1523                            .map_or(range.context.start, |primary| primary.start);
1524                        let jump_position = language::ToPoint::to_point(&jump_anchor, buffer);
1525
1526                        enum JumpIcon {}
1527                        MouseEventHandler::<JumpIcon, _>::new(id.into(), cx, |state, _| {
1528                            let style = style.jump_icon.style_for(state, false);
1529                            Svg::new("icons/arrow_up_right_8.svg")
1530                                .with_color(style.color)
1531                                .constrained()
1532                                .with_width(style.icon_width)
1533                                .aligned()
1534                                .contained()
1535                                .with_style(style.container)
1536                                .constrained()
1537                                .with_width(style.button_width)
1538                                .with_height(style.button_width)
1539                        })
1540                        .with_cursor_style(CursorStyle::PointingHand)
1541                        .on_click(MouseButton::Left, move |_, editor, cx| {
1542                            if let Some(workspace) = editor
1543                                .workspace
1544                                .as_ref()
1545                                .and_then(|(workspace, _)| workspace.upgrade(cx))
1546                            {
1547                                workspace.update(cx, |workspace, cx| {
1548                                    Editor::jump(
1549                                        workspace,
1550                                        jump_path.clone(),
1551                                        jump_position,
1552                                        jump_anchor,
1553                                        cx,
1554                                    );
1555                                });
1556                            }
1557                        })
1558                        .with_tooltip::<JumpIcon>(
1559                            id.into(),
1560                            "Jump to Buffer".to_string(),
1561                            Some(Box::new(crate::OpenExcerpts)),
1562                            tooltip_style.clone(),
1563                            cx,
1564                        )
1565                        .aligned()
1566                        .flex_float()
1567                    });
1568
1569                    if *starts_new_buffer {
1570                        let style = &self.style.diagnostic_path_header;
1571                        let font_size =
1572                            (style.text_scale_factor * self.style.text.font_size).round();
1573
1574                        let path = buffer.resolve_file_path(cx, include_root);
1575                        let mut filename = None;
1576                        let mut parent_path = None;
1577                        // Can't use .and_then() because `.file_name()` and `.parent()` return references :(
1578                        if let Some(path) = path {
1579                            filename = path.file_name().map(|f| f.to_string_lossy().to_string());
1580                            parent_path =
1581                                path.parent().map(|p| p.to_string_lossy().to_string() + "/");
1582                        }
1583
1584                        Flex::row()
1585                            .with_child(
1586                                Label::new(
1587                                    filename.unwrap_or_else(|| "untitled".to_string()),
1588                                    style.filename.text.clone().with_font_size(font_size),
1589                                )
1590                                .contained()
1591                                .with_style(style.filename.container)
1592                                .aligned(),
1593                            )
1594                            .with_children(parent_path.map(|path| {
1595                                Label::new(path, style.path.text.clone().with_font_size(font_size))
1596                                    .contained()
1597                                    .with_style(style.path.container)
1598                                    .aligned()
1599                            }))
1600                            .with_children(jump_icon)
1601                            .contained()
1602                            .with_style(style.container)
1603                            .with_padding_left(gutter_padding)
1604                            .with_padding_right(gutter_padding)
1605                            .expanded()
1606                            .into_any_named("path header block")
1607                    } else {
1608                        let text_style = self.style.text.clone();
1609                        Flex::row()
1610                            .with_child(Label::new("⋯", text_style))
1611                            .with_children(jump_icon)
1612                            .contained()
1613                            .with_padding_left(gutter_padding)
1614                            .with_padding_right(gutter_padding)
1615                            .expanded()
1616                            .into_any_named("collapsed context")
1617                    }
1618                }
1619            };
1620
1621            element.layout(
1622                SizeConstraint {
1623                    min: Vector2F::zero(),
1624                    max: vec2f(width, block.height() as f32 * line_height),
1625                },
1626                editor,
1627                cx,
1628            );
1629            element
1630        };
1631
1632        let mut fixed_block_max_width = 0f32;
1633        let mut blocks = Vec::new();
1634        for (row, block) in fixed_blocks {
1635            let element = render_block(block, f32::INFINITY);
1636            fixed_block_max_width = fixed_block_max_width.max(element.size().x() + em_width);
1637            blocks.push(BlockLayout {
1638                row,
1639                element,
1640                style: BlockStyle::Fixed,
1641            });
1642        }
1643        for (row, block) in non_fixed_blocks {
1644            let style = match block {
1645                TransformBlock::Custom(block) => block.style(),
1646                TransformBlock::ExcerptHeader { .. } => BlockStyle::Sticky,
1647            };
1648            let width = match style {
1649                BlockStyle::Sticky => editor_width,
1650                BlockStyle::Flex => editor_width
1651                    .max(fixed_block_max_width)
1652                    .max(gutter_width + scroll_width),
1653                BlockStyle::Fixed => unreachable!(),
1654            };
1655            let element = render_block(block, width);
1656            blocks.push(BlockLayout {
1657                row,
1658                element,
1659                style,
1660            });
1661        }
1662        (
1663            scroll_width.max(fixed_block_max_width - gutter_width),
1664            blocks,
1665        )
1666    }
1667}
1668
1669struct HighlightedChunk<'a> {
1670    chunk: &'a str,
1671    style: Option<HighlightStyle>,
1672    is_tab: bool,
1673}
1674
1675#[derive(Debug)]
1676pub struct LineWithInvisibles {
1677    pub line: Line,
1678    invisibles: Vec<Invisible>,
1679}
1680
1681impl LineWithInvisibles {
1682    fn from_chunks<'a>(
1683        chunks: impl Iterator<Item = HighlightedChunk<'a>>,
1684        text_style: &TextStyle,
1685        text_layout_cache: &TextLayoutCache,
1686        font_cache: &Arc<FontCache>,
1687        max_line_len: usize,
1688        max_line_count: usize,
1689        line_number_layouts: &[Option<Line>],
1690        editor_mode: EditorMode,
1691    ) -> Vec<Self> {
1692        let mut layouts = Vec::with_capacity(max_line_count);
1693        let mut line = String::new();
1694        let mut invisibles = Vec::new();
1695        let mut styles = Vec::new();
1696        let mut non_whitespace_added = false;
1697        let mut row = 0;
1698        let mut line_exceeded_max_len = false;
1699        for highlighted_chunk in chunks.chain([HighlightedChunk {
1700            chunk: "\n",
1701            style: None,
1702            is_tab: false,
1703        }]) {
1704            for (ix, mut line_chunk) in highlighted_chunk.chunk.split('\n').enumerate() {
1705                if ix > 0 {
1706                    layouts.push(Self {
1707                        line: text_layout_cache.layout_str(&line, text_style.font_size, &styles),
1708                        invisibles: invisibles.drain(..).collect(),
1709                    });
1710
1711                    line.clear();
1712                    styles.clear();
1713                    row += 1;
1714                    line_exceeded_max_len = false;
1715                    non_whitespace_added = false;
1716                    if row == max_line_count {
1717                        return layouts;
1718                    }
1719                }
1720
1721                if !line_chunk.is_empty() && !line_exceeded_max_len {
1722                    let text_style = if let Some(style) = highlighted_chunk.style {
1723                        text_style
1724                            .clone()
1725                            .highlight(style, font_cache)
1726                            .map(Cow::Owned)
1727                            .unwrap_or_else(|_| Cow::Borrowed(text_style))
1728                    } else {
1729                        Cow::Borrowed(text_style)
1730                    };
1731
1732                    if line.len() + line_chunk.len() > max_line_len {
1733                        let mut chunk_len = max_line_len - line.len();
1734                        while !line_chunk.is_char_boundary(chunk_len) {
1735                            chunk_len -= 1;
1736                        }
1737                        line_chunk = &line_chunk[..chunk_len];
1738                        line_exceeded_max_len = true;
1739                    }
1740
1741                    styles.push((
1742                        line_chunk.len(),
1743                        RunStyle {
1744                            font_id: text_style.font_id,
1745                            color: text_style.color,
1746                            underline: text_style.underline,
1747                        },
1748                    ));
1749
1750                    if editor_mode == EditorMode::Full {
1751                        // Line wrap pads its contents with fake whitespaces,
1752                        // avoid printing them
1753                        let inside_wrapped_string = line_number_layouts
1754                            .get(row)
1755                            .and_then(|layout| layout.as_ref())
1756                            .is_none();
1757                        if highlighted_chunk.is_tab {
1758                            if non_whitespace_added || !inside_wrapped_string {
1759                                invisibles.push(Invisible::Tab {
1760                                    line_start_offset: line.len(),
1761                                });
1762                            }
1763                        } else {
1764                            invisibles.extend(
1765                                line_chunk
1766                                    .chars()
1767                                    .enumerate()
1768                                    .filter(|(_, line_char)| {
1769                                        let is_whitespace = line_char.is_whitespace();
1770                                        non_whitespace_added |= !is_whitespace;
1771                                        is_whitespace
1772                                            && (non_whitespace_added || !inside_wrapped_string)
1773                                    })
1774                                    .map(|(whitespace_index, _)| Invisible::Whitespace {
1775                                        line_offset: line.len() + whitespace_index,
1776                                    }),
1777                            )
1778                        }
1779                    }
1780
1781                    line.push_str(line_chunk);
1782                }
1783            }
1784        }
1785
1786        layouts
1787    }
1788
1789    fn draw(
1790        &self,
1791        layout: &LayoutState,
1792        row: u32,
1793        scroll_top: f32,
1794        scene: &mut SceneBuilder,
1795        content_origin: Vector2F,
1796        scroll_left: f32,
1797        visible_text_bounds: RectF,
1798        whitespace_setting: ShowWhitespaceSetting,
1799        selection_ranges: &[Range<DisplayPoint>],
1800        visible_bounds: RectF,
1801        cx: &mut ViewContext<Editor>,
1802    ) {
1803        let line_height = layout.position_map.line_height;
1804        let line_y = row as f32 * line_height - scroll_top;
1805
1806        self.line.paint(
1807            scene,
1808            content_origin + vec2f(-scroll_left, line_y),
1809            visible_text_bounds,
1810            line_height,
1811            cx,
1812        );
1813
1814        self.draw_invisibles(
1815            &selection_ranges,
1816            layout,
1817            content_origin,
1818            scroll_left,
1819            line_y,
1820            row,
1821            scene,
1822            visible_bounds,
1823            line_height,
1824            whitespace_setting,
1825            cx,
1826        );
1827    }
1828
1829    fn draw_invisibles(
1830        &self,
1831        selection_ranges: &[Range<DisplayPoint>],
1832        layout: &LayoutState,
1833        content_origin: Vector2F,
1834        scroll_left: f32,
1835        line_y: f32,
1836        row: u32,
1837        scene: &mut SceneBuilder,
1838        visible_bounds: RectF,
1839        line_height: f32,
1840        whitespace_setting: ShowWhitespaceSetting,
1841        cx: &mut ViewContext<Editor>,
1842    ) {
1843        let allowed_invisibles_regions = match whitespace_setting {
1844            ShowWhitespaceSetting::None => return,
1845            ShowWhitespaceSetting::Selection => Some(selection_ranges),
1846            ShowWhitespaceSetting::All => None,
1847        };
1848
1849        for invisible in &self.invisibles {
1850            let (&token_offset, invisible_symbol) = match invisible {
1851                Invisible::Tab { line_start_offset } => (line_start_offset, &layout.tab_invisible),
1852                Invisible::Whitespace { line_offset } => (line_offset, &layout.space_invisible),
1853            };
1854
1855            let x_offset = self.line.x_for_index(token_offset);
1856            let invisible_offset =
1857                (layout.position_map.em_width - invisible_symbol.width()).max(0.0) / 2.0;
1858            let origin = content_origin + vec2f(-scroll_left + x_offset + invisible_offset, line_y);
1859
1860            if let Some(allowed_regions) = allowed_invisibles_regions {
1861                let invisible_point = DisplayPoint::new(row, token_offset as u32);
1862                if !allowed_regions
1863                    .iter()
1864                    .any(|region| region.start <= invisible_point && invisible_point < region.end)
1865                {
1866                    continue;
1867                }
1868            }
1869            invisible_symbol.paint(scene, origin, visible_bounds, line_height, cx);
1870        }
1871    }
1872}
1873
1874#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1875enum Invisible {
1876    Tab { line_start_offset: usize },
1877    Whitespace { line_offset: usize },
1878}
1879
1880impl Element<Editor> for EditorElement {
1881    type LayoutState = LayoutState;
1882    type PaintState = ();
1883
1884    fn layout(
1885        &mut self,
1886        constraint: SizeConstraint,
1887        editor: &mut Editor,
1888        cx: &mut LayoutContext<Editor>,
1889    ) -> (Vector2F, Self::LayoutState) {
1890        let mut size = constraint.max;
1891        if size.x().is_infinite() {
1892            unimplemented!("we don't yet handle an infinite width constraint on buffer elements");
1893        }
1894
1895        let snapshot = editor.snapshot(cx);
1896        let style = self.style.clone();
1897        let line_height = style.text.line_height(cx.font_cache());
1898
1899        let gutter_padding;
1900        let gutter_width;
1901        let gutter_margin;
1902        if snapshot.mode == EditorMode::Full {
1903            let em_width = style.text.em_width(cx.font_cache());
1904            gutter_padding = (em_width * style.gutter_padding_factor).round();
1905            gutter_width = self.max_line_number_width(&snapshot, cx) + gutter_padding * 2.0;
1906            gutter_margin = -style.text.descent(cx.font_cache());
1907        } else {
1908            gutter_padding = 0.0;
1909            gutter_width = 0.0;
1910            gutter_margin = 0.0;
1911        };
1912
1913        let text_width = size.x() - gutter_width;
1914        let em_width = style.text.em_width(cx.font_cache());
1915        let em_advance = style.text.em_advance(cx.font_cache());
1916        let overscroll = vec2f(em_width, 0.);
1917        let snapshot = {
1918            editor.set_visible_line_count(size.y() / line_height);
1919
1920            let editor_width = text_width - gutter_margin - overscroll.x() - em_width;
1921            let wrap_width = match editor.soft_wrap_mode(cx) {
1922                SoftWrap::None => (MAX_LINE_LEN / 2) as f32 * em_advance,
1923                SoftWrap::EditorWidth => editor_width,
1924                SoftWrap::Column(column) => editor_width.min(column as f32 * em_advance),
1925            };
1926
1927            if editor.set_wrap_width(Some(wrap_width), cx) {
1928                editor.snapshot(cx)
1929            } else {
1930                snapshot
1931            }
1932        };
1933
1934        let scroll_height = (snapshot.max_point().row() + 1) as f32 * line_height;
1935        if let EditorMode::AutoHeight { max_lines } = snapshot.mode {
1936            size.set_y(
1937                scroll_height
1938                    .min(constraint.max_along(Axis::Vertical))
1939                    .max(constraint.min_along(Axis::Vertical))
1940                    .min(line_height * max_lines as f32),
1941            )
1942        } else if let EditorMode::SingleLine = snapshot.mode {
1943            size.set_y(
1944                line_height
1945                    .min(constraint.max_along(Axis::Vertical))
1946                    .max(constraint.min_along(Axis::Vertical)),
1947            )
1948        } else if size.y().is_infinite() {
1949            size.set_y(scroll_height);
1950        }
1951        let gutter_size = vec2f(gutter_width, size.y());
1952        let text_size = vec2f(text_width, size.y());
1953
1954        let autoscroll_horizontally = editor.autoscroll_vertically(size.y(), line_height, cx);
1955        let mut snapshot = editor.snapshot(cx);
1956
1957        let scroll_position = snapshot.scroll_position();
1958        // The scroll position is a fractional point, the whole number of which represents
1959        // the top of the window in terms of display rows.
1960        let start_row = scroll_position.y() as u32;
1961        let height_in_lines = size.y() / line_height;
1962        let max_row = snapshot.max_point().row();
1963
1964        // Add 1 to ensure selections bleed off screen
1965        let end_row = 1 + cmp::min(
1966            (scroll_position.y() + height_in_lines).ceil() as u32,
1967            max_row,
1968        );
1969
1970        let start_anchor = if start_row == 0 {
1971            Anchor::min()
1972        } else {
1973            snapshot
1974                .buffer_snapshot
1975                .anchor_before(DisplayPoint::new(start_row, 0).to_offset(&snapshot, Bias::Left))
1976        };
1977        let end_anchor = if end_row > max_row {
1978            Anchor::max()
1979        } else {
1980            snapshot
1981                .buffer_snapshot
1982                .anchor_before(DisplayPoint::new(end_row, 0).to_offset(&snapshot, Bias::Right))
1983        };
1984
1985        let mut selections: Vec<(ReplicaId, Vec<SelectionLayout>)> = Vec::new();
1986        let mut active_rows = BTreeMap::new();
1987        let mut fold_ranges = Vec::new();
1988        let is_singleton = editor.is_singleton(cx);
1989
1990        let highlighted_rows = editor.highlighted_rows();
1991        let theme = theme::current(cx);
1992        let highlighted_ranges = editor.background_highlights_in_range(
1993            start_anchor..end_anchor,
1994            &snapshot.display_snapshot,
1995            theme.as_ref(),
1996        );
1997
1998        fold_ranges.extend(
1999            snapshot
2000                .folds_in_range(start_anchor..end_anchor)
2001                .map(|anchor| {
2002                    let start = anchor.start.to_point(&snapshot.buffer_snapshot);
2003                    (
2004                        start.row,
2005                        start.to_display_point(&snapshot.display_snapshot)
2006                            ..anchor.end.to_display_point(&snapshot),
2007                    )
2008                }),
2009        );
2010
2011        let mut remote_selections = HashMap::default();
2012        for (replica_id, line_mode, cursor_shape, selection) in snapshot
2013            .buffer_snapshot
2014            .remote_selections_in_range(&(start_anchor..end_anchor))
2015        {
2016            // The local selections match the leader's selections.
2017            if Some(replica_id) == editor.leader_replica_id {
2018                continue;
2019            }
2020            remote_selections
2021                .entry(replica_id)
2022                .or_insert(Vec::new())
2023                .push(SelectionLayout::new(
2024                    selection,
2025                    line_mode,
2026                    cursor_shape,
2027                    &snapshot.display_snapshot,
2028                ));
2029        }
2030        selections.extend(remote_selections);
2031
2032        if editor.show_local_selections {
2033            let mut local_selections = editor
2034                .selections
2035                .disjoint_in_range(start_anchor..end_anchor, cx);
2036            local_selections.extend(editor.selections.pending(cx));
2037            for selection in &local_selections {
2038                let is_empty = selection.start == selection.end;
2039                let selection_start = snapshot.prev_line_boundary(selection.start).1;
2040                let selection_end = snapshot.next_line_boundary(selection.end).1;
2041                for row in cmp::max(selection_start.row(), start_row)
2042                    ..=cmp::min(selection_end.row(), end_row)
2043                {
2044                    let contains_non_empty_selection = active_rows.entry(row).or_insert(!is_empty);
2045                    *contains_non_empty_selection |= !is_empty;
2046                }
2047            }
2048
2049            // Render the local selections in the leader's color when following.
2050            let local_replica_id = editor
2051                .leader_replica_id
2052                .unwrap_or_else(|| editor.replica_id(cx));
2053
2054            selections.push((
2055                local_replica_id,
2056                local_selections
2057                    .into_iter()
2058                    .map(|selection| {
2059                        SelectionLayout::new(
2060                            selection,
2061                            editor.selections.line_mode,
2062                            editor.cursor_shape,
2063                            &snapshot.display_snapshot,
2064                        )
2065                    })
2066                    .collect(),
2067            ));
2068        }
2069
2070        let show_scrollbars = match settings::get::<EditorSettings>(cx).show_scrollbars {
2071            ShowScrollbars::Auto => {
2072                snapshot.has_scrollbar_info(is_singleton)
2073                    || editor.scroll_manager.scrollbars_visible()
2074            }
2075            ShowScrollbars::System => editor.scroll_manager.scrollbars_visible(),
2076            ShowScrollbars::Always => true,
2077            ShowScrollbars::Never => false,
2078        };
2079
2080        let include_root = editor
2081            .project
2082            .as_ref()
2083            .map(|project| project.read(cx).visible_worktrees(cx).count() > 1)
2084            .unwrap_or_default();
2085
2086        let fold_ranges: Vec<(BufferRow, Range<DisplayPoint>, Color)> = fold_ranges
2087            .into_iter()
2088            .map(|(id, fold)| {
2089                let color = self
2090                    .style
2091                    .folds
2092                    .ellipses
2093                    .background
2094                    .style_for(&mut cx.mouse_state::<FoldMarkers>(id as usize), false)
2095                    .color;
2096
2097                (id, fold, color)
2098            })
2099            .collect();
2100
2101        let (line_number_layouts, fold_statuses) = self.layout_line_numbers(
2102            start_row..end_row,
2103            &active_rows,
2104            is_singleton,
2105            &snapshot,
2106            cx,
2107        );
2108
2109        let display_hunks = self.layout_git_gutters(start_row..end_row, &snapshot);
2110
2111        let scrollbar_row_range = scroll_position.y()..(scroll_position.y() + height_in_lines);
2112
2113        let mut max_visible_line_width = 0.0;
2114        let line_layouts =
2115            self.layout_lines(start_row..end_row, &line_number_layouts, &snapshot, cx);
2116        for line_with_invisibles in &line_layouts {
2117            if line_with_invisibles.line.width() > max_visible_line_width {
2118                max_visible_line_width = line_with_invisibles.line.width();
2119            }
2120        }
2121
2122        let style = self.style.clone();
2123        let longest_line_width = layout_line(
2124            snapshot.longest_row(),
2125            &snapshot,
2126            &style,
2127            cx.text_layout_cache(),
2128        )
2129        .width();
2130        let scroll_width = longest_line_width.max(max_visible_line_width) + overscroll.x();
2131        let em_width = style.text.em_width(cx.font_cache());
2132        let (scroll_width, blocks) = self.layout_blocks(
2133            start_row..end_row,
2134            &snapshot,
2135            size.x(),
2136            scroll_width,
2137            gutter_padding,
2138            gutter_width,
2139            em_width,
2140            gutter_width + gutter_margin,
2141            line_height,
2142            &style,
2143            &line_layouts,
2144            include_root,
2145            editor,
2146            cx,
2147        );
2148
2149        let scroll_max = vec2f(
2150            ((scroll_width - text_size.x()) / em_width).max(0.0),
2151            max_row as f32,
2152        );
2153
2154        let clamped = editor.scroll_manager.clamp_scroll_left(scroll_max.x());
2155
2156        let autoscrolled = if autoscroll_horizontally {
2157            editor.autoscroll_horizontally(
2158                start_row,
2159                text_size.x(),
2160                scroll_width,
2161                em_width,
2162                &line_layouts,
2163                cx,
2164            )
2165        } else {
2166            false
2167        };
2168
2169        if clamped || autoscrolled {
2170            snapshot = editor.snapshot(cx);
2171        }
2172
2173        let newest_selection_head = editor
2174            .selections
2175            .newest::<usize>(cx)
2176            .head()
2177            .to_display_point(&snapshot);
2178        let style = editor.style(cx);
2179
2180        let mut context_menu = None;
2181        let mut code_actions_indicator = None;
2182        if (start_row..end_row).contains(&newest_selection_head.row()) {
2183            if editor.context_menu_visible() {
2184                context_menu = editor.render_context_menu(newest_selection_head, style.clone(), cx);
2185            }
2186
2187            let active = matches!(
2188                editor.context_menu,
2189                Some(crate::ContextMenu::CodeActions(_))
2190            );
2191
2192            code_actions_indicator = editor
2193                .render_code_actions_indicator(&style, active, cx)
2194                .map(|indicator| (newest_selection_head.row(), indicator));
2195        }
2196
2197        let visible_rows = start_row..start_row + line_layouts.len() as u32;
2198        let mut hover = editor
2199            .hover_state
2200            .render(&snapshot, &style, visible_rows, cx);
2201        let mode = editor.mode;
2202
2203        let mut fold_indicators = editor.render_fold_indicators(
2204            fold_statuses,
2205            &style,
2206            editor.gutter_hovered,
2207            line_height,
2208            gutter_margin,
2209            cx,
2210        );
2211
2212        if let Some((_, context_menu)) = context_menu.as_mut() {
2213            context_menu.layout(
2214                SizeConstraint {
2215                    min: Vector2F::zero(),
2216                    max: vec2f(
2217                        cx.window_size().x() * 0.7,
2218                        (12. * line_height).min((size.y() - line_height) / 2.),
2219                    ),
2220                },
2221                editor,
2222                cx,
2223            );
2224        }
2225
2226        if let Some((_, indicator)) = code_actions_indicator.as_mut() {
2227            indicator.layout(
2228                SizeConstraint::strict_along(
2229                    Axis::Vertical,
2230                    line_height * style.code_actions.vertical_scale,
2231                ),
2232                editor,
2233                cx,
2234            );
2235        }
2236
2237        for fold_indicator in fold_indicators.iter_mut() {
2238            if let Some(indicator) = fold_indicator.as_mut() {
2239                indicator.layout(
2240                    SizeConstraint::strict_along(
2241                        Axis::Vertical,
2242                        line_height * style.code_actions.vertical_scale,
2243                    ),
2244                    editor,
2245                    cx,
2246                );
2247            }
2248        }
2249
2250        if let Some((_, hover_popovers)) = hover.as_mut() {
2251            for hover_popover in hover_popovers.iter_mut() {
2252                hover_popover.layout(
2253                    SizeConstraint {
2254                        min: Vector2F::zero(),
2255                        max: vec2f(
2256                            (120. * em_width) // Default size
2257                                .min(size.x() / 2.) // Shrink to half of the editor width
2258                                .max(MIN_POPOVER_CHARACTER_WIDTH * em_width), // Apply minimum width of 20 characters
2259                            (16. * line_height) // Default size
2260                                .min(size.y() / 2.) // Shrink to half of the editor height
2261                                .max(MIN_POPOVER_LINE_HEIGHT * line_height), // Apply minimum height of 4 lines
2262                        ),
2263                    },
2264                    editor,
2265                    cx,
2266                );
2267            }
2268        }
2269
2270        let invisible_symbol_font_size = self.style.text.font_size / 2.0;
2271        let invisible_symbol_style = RunStyle {
2272            color: self.style.whitespace,
2273            font_id: self.style.text.font_id,
2274            underline: Default::default(),
2275        };
2276
2277        (
2278            size,
2279            LayoutState {
2280                mode,
2281                position_map: Arc::new(PositionMap {
2282                    size,
2283                    scroll_max,
2284                    line_layouts,
2285                    line_height,
2286                    em_width,
2287                    em_advance,
2288                    snapshot,
2289                }),
2290                visible_display_row_range: start_row..end_row,
2291                gutter_size,
2292                gutter_padding,
2293                text_size,
2294                scrollbar_row_range,
2295                show_scrollbars,
2296                is_singleton,
2297                max_row,
2298                gutter_margin,
2299                active_rows,
2300                highlighted_rows,
2301                highlighted_ranges,
2302                fold_ranges,
2303                line_number_layouts,
2304                display_hunks,
2305                blocks,
2306                selections,
2307                context_menu,
2308                code_actions_indicator,
2309                fold_indicators,
2310                tab_invisible: cx.text_layout_cache().layout_str(
2311                    "→",
2312                    invisible_symbol_font_size,
2313                    &[("→".len(), invisible_symbol_style)],
2314                ),
2315                space_invisible: cx.text_layout_cache().layout_str(
2316                    "•",
2317                    invisible_symbol_font_size,
2318                    &[("•".len(), invisible_symbol_style)],
2319                ),
2320                hover_popovers: hover,
2321            },
2322        )
2323    }
2324
2325    fn paint(
2326        &mut self,
2327        scene: &mut SceneBuilder,
2328        bounds: RectF,
2329        visible_bounds: RectF,
2330        layout: &mut Self::LayoutState,
2331        editor: &mut Editor,
2332        cx: &mut ViewContext<Editor>,
2333    ) -> Self::PaintState {
2334        let visible_bounds = bounds.intersection(visible_bounds).unwrap_or_default();
2335        scene.push_layer(Some(visible_bounds));
2336
2337        let gutter_bounds = RectF::new(bounds.origin(), layout.gutter_size);
2338        let text_bounds = RectF::new(
2339            bounds.origin() + vec2f(layout.gutter_size.x(), 0.0),
2340            layout.text_size,
2341        );
2342
2343        Self::attach_mouse_handlers(
2344            scene,
2345            &layout.position_map,
2346            layout.hover_popovers.is_some(),
2347            visible_bounds,
2348            text_bounds,
2349            gutter_bounds,
2350            bounds,
2351            cx,
2352        );
2353
2354        self.paint_background(scene, gutter_bounds, text_bounds, layout);
2355        if layout.gutter_size.x() > 0. {
2356            self.paint_gutter(scene, gutter_bounds, visible_bounds, layout, editor, cx);
2357        }
2358        self.paint_text(scene, text_bounds, visible_bounds, layout, editor, cx);
2359
2360        scene.push_layer(Some(bounds));
2361        if !layout.blocks.is_empty() {
2362            self.paint_blocks(scene, bounds, visible_bounds, layout, editor, cx);
2363        }
2364        self.paint_scrollbar(scene, bounds, layout, cx);
2365        scene.pop_layer();
2366
2367        scene.pop_layer();
2368    }
2369
2370    fn rect_for_text_range(
2371        &self,
2372        range_utf16: Range<usize>,
2373        bounds: RectF,
2374        _: RectF,
2375        layout: &Self::LayoutState,
2376        _: &Self::PaintState,
2377        _: &Editor,
2378        _: &ViewContext<Editor>,
2379    ) -> Option<RectF> {
2380        let text_bounds = RectF::new(
2381            bounds.origin() + vec2f(layout.gutter_size.x(), 0.0),
2382            layout.text_size,
2383        );
2384        let content_origin = text_bounds.origin() + vec2f(layout.gutter_margin, 0.);
2385        let scroll_position = layout.position_map.snapshot.scroll_position();
2386        let start_row = scroll_position.y() as u32;
2387        let scroll_top = scroll_position.y() * layout.position_map.line_height;
2388        let scroll_left = scroll_position.x() * layout.position_map.em_width;
2389
2390        let range_start = OffsetUtf16(range_utf16.start)
2391            .to_display_point(&layout.position_map.snapshot.display_snapshot);
2392        if range_start.row() < start_row {
2393            return None;
2394        }
2395
2396        let line = &layout
2397            .position_map
2398            .line_layouts
2399            .get((range_start.row() - start_row) as usize)?
2400            .line;
2401        let range_start_x = line.x_for_index(range_start.column() as usize);
2402        let range_start_y = range_start.row() as f32 * layout.position_map.line_height;
2403        Some(RectF::new(
2404            content_origin
2405                + vec2f(
2406                    range_start_x,
2407                    range_start_y + layout.position_map.line_height,
2408                )
2409                - vec2f(scroll_left, scroll_top),
2410            vec2f(
2411                layout.position_map.em_width,
2412                layout.position_map.line_height,
2413            ),
2414        ))
2415    }
2416
2417    fn debug(
2418        &self,
2419        bounds: RectF,
2420        _: &Self::LayoutState,
2421        _: &Self::PaintState,
2422        _: &Editor,
2423        _: &ViewContext<Editor>,
2424    ) -> json::Value {
2425        json!({
2426            "type": "BufferElement",
2427            "bounds": bounds.to_json()
2428        })
2429    }
2430}
2431
2432type BufferRow = u32;
2433
2434pub struct LayoutState {
2435    position_map: Arc<PositionMap>,
2436    gutter_size: Vector2F,
2437    gutter_padding: f32,
2438    gutter_margin: f32,
2439    text_size: Vector2F,
2440    mode: EditorMode,
2441    visible_display_row_range: Range<u32>,
2442    active_rows: BTreeMap<u32, bool>,
2443    highlighted_rows: Option<Range<u32>>,
2444    line_number_layouts: Vec<Option<text_layout::Line>>,
2445    display_hunks: Vec<DisplayDiffHunk>,
2446    blocks: Vec<BlockLayout>,
2447    highlighted_ranges: Vec<(Range<DisplayPoint>, Color)>,
2448    fold_ranges: Vec<(BufferRow, Range<DisplayPoint>, Color)>,
2449    selections: Vec<(ReplicaId, Vec<SelectionLayout>)>,
2450    scrollbar_row_range: Range<f32>,
2451    show_scrollbars: bool,
2452    is_singleton: bool,
2453    max_row: u32,
2454    context_menu: Option<(DisplayPoint, AnyElement<Editor>)>,
2455    code_actions_indicator: Option<(u32, AnyElement<Editor>)>,
2456    hover_popovers: Option<(DisplayPoint, Vec<AnyElement<Editor>>)>,
2457    fold_indicators: Vec<Option<AnyElement<Editor>>>,
2458    tab_invisible: Line,
2459    space_invisible: Line,
2460}
2461
2462struct PositionMap {
2463    size: Vector2F,
2464    line_height: f32,
2465    scroll_max: Vector2F,
2466    em_width: f32,
2467    em_advance: f32,
2468    line_layouts: Vec<LineWithInvisibles>,
2469    snapshot: EditorSnapshot,
2470}
2471
2472impl PositionMap {
2473    /// Returns two display points:
2474    /// 1. The nearest *valid* position in the editor
2475    /// 2. An unclipped, potentially *invalid* position that maps directly to
2476    ///    the given pixel position.
2477    fn point_for_position(
2478        &self,
2479        text_bounds: RectF,
2480        position: Vector2F,
2481    ) -> (DisplayPoint, DisplayPoint) {
2482        let scroll_position = self.snapshot.scroll_position();
2483        let position = position - text_bounds.origin();
2484        let y = position.y().max(0.0).min(self.size.y());
2485        let x = position.x() + (scroll_position.x() * self.em_width);
2486        let row = (y / self.line_height + scroll_position.y()) as u32;
2487        let (column, x_overshoot) = if let Some(line) = self
2488            .line_layouts
2489            .get(row as usize - scroll_position.y() as usize)
2490            .map(|line_with_spaces| &line_with_spaces.line)
2491        {
2492            if let Some(ix) = line.index_for_x(x) {
2493                (ix as u32, 0.0)
2494            } else {
2495                (line.len() as u32, 0f32.max(x - line.width()))
2496            }
2497        } else {
2498            (0, x)
2499        };
2500
2501        let mut target_point = DisplayPoint::new(row, column);
2502        let point = self.snapshot.clip_point(target_point, Bias::Left);
2503        *target_point.column_mut() += (x_overshoot / self.em_advance) as u32;
2504
2505        (point, target_point)
2506    }
2507}
2508
2509struct BlockLayout {
2510    row: u32,
2511    element: AnyElement<Editor>,
2512    style: BlockStyle,
2513}
2514
2515fn layout_line(
2516    row: u32,
2517    snapshot: &EditorSnapshot,
2518    style: &EditorStyle,
2519    layout_cache: &TextLayoutCache,
2520) -> text_layout::Line {
2521    let mut line = snapshot.line(row);
2522
2523    if line.len() > MAX_LINE_LEN {
2524        let mut len = MAX_LINE_LEN;
2525        while !line.is_char_boundary(len) {
2526            len -= 1;
2527        }
2528
2529        line.truncate(len);
2530    }
2531
2532    layout_cache.layout_str(
2533        &line,
2534        style.text.font_size,
2535        &[(
2536            snapshot.line_len(row) as usize,
2537            RunStyle {
2538                font_id: style.text.font_id,
2539                color: Color::black(),
2540                underline: Default::default(),
2541            },
2542        )],
2543    )
2544}
2545
2546#[derive(Debug)]
2547pub struct Cursor {
2548    origin: Vector2F,
2549    block_width: f32,
2550    line_height: f32,
2551    color: Color,
2552    shape: CursorShape,
2553    block_text: Option<Line>,
2554}
2555
2556impl Cursor {
2557    pub fn new(
2558        origin: Vector2F,
2559        block_width: f32,
2560        line_height: f32,
2561        color: Color,
2562        shape: CursorShape,
2563        block_text: Option<Line>,
2564    ) -> Cursor {
2565        Cursor {
2566            origin,
2567            block_width,
2568            line_height,
2569            color,
2570            shape,
2571            block_text,
2572        }
2573    }
2574
2575    pub fn bounding_rect(&self, origin: Vector2F) -> RectF {
2576        RectF::new(
2577            self.origin + origin,
2578            vec2f(self.block_width, self.line_height),
2579        )
2580    }
2581
2582    pub fn paint(&self, scene: &mut SceneBuilder, origin: Vector2F, cx: &mut WindowContext) {
2583        let bounds = match self.shape {
2584            CursorShape::Bar => RectF::new(self.origin + origin, vec2f(2.0, self.line_height)),
2585            CursorShape::Block | CursorShape::Hollow => RectF::new(
2586                self.origin + origin,
2587                vec2f(self.block_width, self.line_height),
2588            ),
2589            CursorShape::Underscore => RectF::new(
2590                self.origin + origin + Vector2F::new(0.0, self.line_height - 2.0),
2591                vec2f(self.block_width, 2.0),
2592            ),
2593        };
2594
2595        //Draw background or border quad
2596        if matches!(self.shape, CursorShape::Hollow) {
2597            scene.push_quad(Quad {
2598                bounds,
2599                background: None,
2600                border: Border::all(1., self.color),
2601                corner_radius: 0.,
2602            });
2603        } else {
2604            scene.push_quad(Quad {
2605                bounds,
2606                background: Some(self.color),
2607                border: Default::default(),
2608                corner_radius: 0.,
2609            });
2610        }
2611
2612        if let Some(block_text) = &self.block_text {
2613            block_text.paint(scene, self.origin + origin, bounds, self.line_height, cx);
2614        }
2615    }
2616
2617    pub fn shape(&self) -> CursorShape {
2618        self.shape
2619    }
2620}
2621
2622#[derive(Debug)]
2623pub struct HighlightedRange {
2624    pub start_y: f32,
2625    pub line_height: f32,
2626    pub lines: Vec<HighlightedRangeLine>,
2627    pub color: Color,
2628    pub corner_radius: f32,
2629}
2630
2631#[derive(Debug)]
2632pub struct HighlightedRangeLine {
2633    pub start_x: f32,
2634    pub end_x: f32,
2635}
2636
2637impl HighlightedRange {
2638    pub fn paint(&self, bounds: RectF, scene: &mut SceneBuilder) {
2639        if self.lines.len() >= 2 && self.lines[0].start_x > self.lines[1].end_x {
2640            self.paint_lines(self.start_y, &self.lines[0..1], bounds, scene);
2641            self.paint_lines(
2642                self.start_y + self.line_height,
2643                &self.lines[1..],
2644                bounds,
2645                scene,
2646            );
2647        } else {
2648            self.paint_lines(self.start_y, &self.lines, bounds, scene);
2649        }
2650    }
2651
2652    fn paint_lines(
2653        &self,
2654        start_y: f32,
2655        lines: &[HighlightedRangeLine],
2656        bounds: RectF,
2657        scene: &mut SceneBuilder,
2658    ) {
2659        if lines.is_empty() {
2660            return;
2661        }
2662
2663        let mut path = PathBuilder::new();
2664        let first_line = lines.first().unwrap();
2665        let last_line = lines.last().unwrap();
2666
2667        let first_top_left = vec2f(first_line.start_x, start_y);
2668        let first_top_right = vec2f(first_line.end_x, start_y);
2669
2670        let curve_height = vec2f(0., self.corner_radius);
2671        let curve_width = |start_x: f32, end_x: f32| {
2672            let max = (end_x - start_x) / 2.;
2673            let width = if max < self.corner_radius {
2674                max
2675            } else {
2676                self.corner_radius
2677            };
2678
2679            vec2f(width, 0.)
2680        };
2681
2682        let top_curve_width = curve_width(first_line.start_x, first_line.end_x);
2683        path.reset(first_top_right - top_curve_width);
2684        path.curve_to(first_top_right + curve_height, first_top_right);
2685
2686        let mut iter = lines.iter().enumerate().peekable();
2687        while let Some((ix, line)) = iter.next() {
2688            let bottom_right = vec2f(line.end_x, start_y + (ix + 1) as f32 * self.line_height);
2689
2690            if let Some((_, next_line)) = iter.peek() {
2691                let next_top_right = vec2f(next_line.end_x, bottom_right.y());
2692
2693                match next_top_right.x().partial_cmp(&bottom_right.x()).unwrap() {
2694                    Ordering::Equal => {
2695                        path.line_to(bottom_right);
2696                    }
2697                    Ordering::Less => {
2698                        let curve_width = curve_width(next_top_right.x(), bottom_right.x());
2699                        path.line_to(bottom_right - curve_height);
2700                        if self.corner_radius > 0. {
2701                            path.curve_to(bottom_right - curve_width, bottom_right);
2702                        }
2703                        path.line_to(next_top_right + curve_width);
2704                        if self.corner_radius > 0. {
2705                            path.curve_to(next_top_right + curve_height, next_top_right);
2706                        }
2707                    }
2708                    Ordering::Greater => {
2709                        let curve_width = curve_width(bottom_right.x(), next_top_right.x());
2710                        path.line_to(bottom_right - curve_height);
2711                        if self.corner_radius > 0. {
2712                            path.curve_to(bottom_right + curve_width, bottom_right);
2713                        }
2714                        path.line_to(next_top_right - curve_width);
2715                        if self.corner_radius > 0. {
2716                            path.curve_to(next_top_right + curve_height, next_top_right);
2717                        }
2718                    }
2719                }
2720            } else {
2721                let curve_width = curve_width(line.start_x, line.end_x);
2722                path.line_to(bottom_right - curve_height);
2723                if self.corner_radius > 0. {
2724                    path.curve_to(bottom_right - curve_width, bottom_right);
2725                }
2726
2727                let bottom_left = vec2f(line.start_x, bottom_right.y());
2728                path.line_to(bottom_left + curve_width);
2729                if self.corner_radius > 0. {
2730                    path.curve_to(bottom_left - curve_height, bottom_left);
2731                }
2732            }
2733        }
2734
2735        if first_line.start_x > last_line.start_x {
2736            let curve_width = curve_width(last_line.start_x, first_line.start_x);
2737            let second_top_left = vec2f(last_line.start_x, start_y + self.line_height);
2738            path.line_to(second_top_left + curve_height);
2739            if self.corner_radius > 0. {
2740                path.curve_to(second_top_left + curve_width, second_top_left);
2741            }
2742            let first_bottom_left = vec2f(first_line.start_x, second_top_left.y());
2743            path.line_to(first_bottom_left - curve_width);
2744            if self.corner_radius > 0. {
2745                path.curve_to(first_bottom_left - curve_height, first_bottom_left);
2746            }
2747        }
2748
2749        path.line_to(first_top_left + curve_height);
2750        if self.corner_radius > 0. {
2751            path.curve_to(first_top_left + top_curve_width, first_top_left);
2752        }
2753        path.line_to(first_top_right - top_curve_width);
2754
2755        scene.push_path(path.build(self.color, Some(bounds)));
2756    }
2757}
2758
2759fn position_to_display_point(
2760    position: Vector2F,
2761    text_bounds: RectF,
2762    position_map: &PositionMap,
2763) -> Option<DisplayPoint> {
2764    if text_bounds.contains_point(position) {
2765        let (point, target_point) = position_map.point_for_position(text_bounds, position);
2766        if point == target_point {
2767            Some(point)
2768        } else {
2769            None
2770        }
2771    } else {
2772        None
2773    }
2774}
2775
2776fn range_to_bounds(
2777    range: &Range<DisplayPoint>,
2778    content_origin: Vector2F,
2779    scroll_left: f32,
2780    scroll_top: f32,
2781    visible_row_range: &Range<u32>,
2782    line_end_overshoot: f32,
2783    position_map: &PositionMap,
2784) -> impl Iterator<Item = RectF> {
2785    let mut bounds: SmallVec<[RectF; 1]> = SmallVec::new();
2786
2787    if range.start == range.end {
2788        return bounds.into_iter();
2789    }
2790
2791    let start_row = visible_row_range.start;
2792    let end_row = visible_row_range.end;
2793
2794    let row_range = if range.end.column() == 0 {
2795        cmp::max(range.start.row(), start_row)..cmp::min(range.end.row(), end_row)
2796    } else {
2797        cmp::max(range.start.row(), start_row)..cmp::min(range.end.row() + 1, end_row)
2798    };
2799
2800    let first_y =
2801        content_origin.y() + row_range.start as f32 * position_map.line_height - scroll_top;
2802
2803    for (idx, row) in row_range.enumerate() {
2804        let line_layout = &position_map.line_layouts[(row - start_row) as usize].line;
2805
2806        let start_x = if row == range.start.row() {
2807            content_origin.x() + line_layout.x_for_index(range.start.column() as usize)
2808                - scroll_left
2809        } else {
2810            content_origin.x() - scroll_left
2811        };
2812
2813        let end_x = if row == range.end.row() {
2814            content_origin.x() + line_layout.x_for_index(range.end.column() as usize) - scroll_left
2815        } else {
2816            content_origin.x() + line_layout.width() + line_end_overshoot - scroll_left
2817        };
2818
2819        bounds.push(RectF::from_points(
2820            vec2f(start_x, first_y + position_map.line_height * idx as f32),
2821            vec2f(end_x, first_y + position_map.line_height * (idx + 1) as f32),
2822        ))
2823    }
2824
2825    bounds.into_iter()
2826}
2827
2828pub fn scale_vertical_mouse_autoscroll_delta(delta: f32) -> f32 {
2829    delta.powf(1.5) / 100.0
2830}
2831
2832fn scale_horizontal_mouse_autoscroll_delta(delta: f32) -> f32 {
2833    delta.powf(1.2) / 300.0
2834}
2835
2836#[cfg(test)]
2837mod tests {
2838    use super::*;
2839    use crate::{
2840        display_map::{BlockDisposition, BlockProperties},
2841        editor_tests::{init_test, update_test_settings},
2842        Editor, MultiBuffer,
2843    };
2844    use gpui::TestAppContext;
2845    use language::language_settings;
2846    use log::info;
2847    use std::{num::NonZeroU32, sync::Arc};
2848    use util::test::sample_text;
2849
2850    #[gpui::test]
2851    fn test_layout_line_numbers(cx: &mut TestAppContext) {
2852        init_test(cx, |_| {});
2853
2854        let (_, editor) = cx.add_window(|cx| {
2855            let buffer = MultiBuffer::build_simple(&sample_text(6, 6, 'a'), cx);
2856            Editor::new(EditorMode::Full, buffer, None, None, cx)
2857        });
2858        let element = EditorElement::new(editor.read_with(cx, |editor, cx| editor.style(cx)));
2859
2860        let layouts = editor.update(cx, |editor, cx| {
2861            let snapshot = editor.snapshot(cx);
2862            element
2863                .layout_line_numbers(0..6, &Default::default(), false, &snapshot, cx)
2864                .0
2865        });
2866        assert_eq!(layouts.len(), 6);
2867    }
2868
2869    #[gpui::test]
2870    fn test_layout_with_placeholder_text_and_blocks(cx: &mut TestAppContext) {
2871        init_test(cx, |_| {});
2872
2873        let (_, editor) = cx.add_window(|cx| {
2874            let buffer = MultiBuffer::build_simple("", cx);
2875            Editor::new(EditorMode::Full, buffer, None, None, cx)
2876        });
2877
2878        editor.update(cx, |editor, cx| {
2879            editor.set_placeholder_text("hello", cx);
2880            editor.insert_blocks(
2881                [BlockProperties {
2882                    style: BlockStyle::Fixed,
2883                    disposition: BlockDisposition::Above,
2884                    height: 3,
2885                    position: Anchor::min(),
2886                    render: Arc::new(|_| Empty::new().into_any()),
2887                }],
2888                cx,
2889            );
2890
2891            // Blur the editor so that it displays placeholder text.
2892            cx.blur();
2893        });
2894
2895        let mut element = EditorElement::new(editor.read_with(cx, |editor, cx| editor.style(cx)));
2896        let (size, mut state) = editor.update(cx, |editor, cx| {
2897            let mut new_parents = Default::default();
2898            let mut notify_views_if_parents_change = Default::default();
2899            let mut layout_cx = LayoutContext::new(
2900                cx,
2901                &mut new_parents,
2902                &mut notify_views_if_parents_change,
2903                false,
2904            );
2905            element.layout(
2906                SizeConstraint::new(vec2f(500., 500.), vec2f(500., 500.)),
2907                editor,
2908                &mut layout_cx,
2909            )
2910        });
2911
2912        assert_eq!(state.position_map.line_layouts.len(), 4);
2913        assert_eq!(
2914            state
2915                .line_number_layouts
2916                .iter()
2917                .map(Option::is_some)
2918                .collect::<Vec<_>>(),
2919            &[false, false, false, true]
2920        );
2921
2922        // Don't panic.
2923        let mut scene = SceneBuilder::new(1.0);
2924        let bounds = RectF::new(Default::default(), size);
2925        editor.update(cx, |editor, cx| {
2926            element.paint(&mut scene, bounds, bounds, &mut state, editor, cx);
2927        });
2928    }
2929
2930    #[gpui::test]
2931    fn test_all_invisibles_drawing(cx: &mut TestAppContext) {
2932        const TAB_SIZE: u32 = 4;
2933
2934        let input_text = "\t \t|\t| a b";
2935        let expected_invisibles = vec![
2936            Invisible::Tab {
2937                line_start_offset: 0,
2938            },
2939            Invisible::Whitespace {
2940                line_offset: TAB_SIZE as usize,
2941            },
2942            Invisible::Tab {
2943                line_start_offset: TAB_SIZE as usize + 1,
2944            },
2945            Invisible::Tab {
2946                line_start_offset: TAB_SIZE as usize * 2 + 1,
2947            },
2948            Invisible::Whitespace {
2949                line_offset: TAB_SIZE as usize * 3 + 1,
2950            },
2951            Invisible::Whitespace {
2952                line_offset: TAB_SIZE as usize * 3 + 3,
2953            },
2954        ];
2955        assert_eq!(
2956            expected_invisibles.len(),
2957            input_text
2958                .chars()
2959                .filter(|initial_char| initial_char.is_whitespace())
2960                .count(),
2961            "Hardcoded expected invisibles differ from the actual ones in '{input_text}'"
2962        );
2963
2964        init_test(cx, |s| {
2965            s.defaults.show_whitespaces = Some(ShowWhitespaceSetting::All);
2966            s.defaults.tab_size = NonZeroU32::new(TAB_SIZE);
2967        });
2968
2969        let actual_invisibles =
2970            collect_invisibles_from_new_editor(cx, EditorMode::Full, &input_text, 500.0);
2971
2972        assert_eq!(expected_invisibles, actual_invisibles);
2973    }
2974
2975    #[gpui::test]
2976    fn test_invisibles_dont_appear_in_certain_editors(cx: &mut TestAppContext) {
2977        init_test(cx, |s| {
2978            s.defaults.show_whitespaces = Some(ShowWhitespaceSetting::All);
2979            s.defaults.tab_size = NonZeroU32::new(4);
2980        });
2981
2982        for editor_mode_without_invisibles in [
2983            EditorMode::SingleLine,
2984            EditorMode::AutoHeight { max_lines: 100 },
2985        ] {
2986            let invisibles = collect_invisibles_from_new_editor(
2987                cx,
2988                editor_mode_without_invisibles,
2989                "\t\t\t| | a b",
2990                500.0,
2991            );
2992            assert!(invisibles.is_empty(),
2993                "For editor mode {editor_mode_without_invisibles:?} no invisibles was expected but got {invisibles:?}");
2994        }
2995    }
2996
2997    #[gpui::test]
2998    fn test_wrapped_invisibles_drawing(cx: &mut TestAppContext) {
2999        let tab_size = 4;
3000        let input_text = "a\tbcd   ".repeat(9);
3001        let repeated_invisibles = [
3002            Invisible::Tab {
3003                line_start_offset: 1,
3004            },
3005            Invisible::Whitespace {
3006                line_offset: tab_size as usize + 3,
3007            },
3008            Invisible::Whitespace {
3009                line_offset: tab_size as usize + 4,
3010            },
3011            Invisible::Whitespace {
3012                line_offset: tab_size as usize + 5,
3013            },
3014        ];
3015        let expected_invisibles = std::iter::once(repeated_invisibles)
3016            .cycle()
3017            .take(9)
3018            .flatten()
3019            .collect::<Vec<_>>();
3020        assert_eq!(
3021            expected_invisibles.len(),
3022            input_text
3023                .chars()
3024                .filter(|initial_char| initial_char.is_whitespace())
3025                .count(),
3026            "Hardcoded expected invisibles differ from the actual ones in '{input_text}'"
3027        );
3028        info!("Expected invisibles: {expected_invisibles:?}");
3029
3030        init_test(cx, |_| {});
3031
3032        // Put the same string with repeating whitespace pattern into editors of various size,
3033        // take deliberately small steps during resizing, to put all whitespace kinds near the wrap point.
3034        let resize_step = 10.0;
3035        let mut editor_width = 200.0;
3036        while editor_width <= 1000.0 {
3037            update_test_settings(cx, |s| {
3038                s.defaults.tab_size = NonZeroU32::new(tab_size);
3039                s.defaults.show_whitespaces = Some(ShowWhitespaceSetting::All);
3040                s.defaults.preferred_line_length = Some(editor_width as u32);
3041                s.defaults.soft_wrap = Some(language_settings::SoftWrap::PreferredLineLength);
3042            });
3043
3044            let actual_invisibles =
3045                collect_invisibles_from_new_editor(cx, EditorMode::Full, &input_text, editor_width);
3046
3047            // Whatever the editor size is, ensure it has the same invisible kinds in the same order
3048            // (no good guarantees about the offsets: wrapping could trigger padding and its tests should check the offsets).
3049            let mut i = 0;
3050            for (actual_index, actual_invisible) in actual_invisibles.iter().enumerate() {
3051                i = actual_index;
3052                match expected_invisibles.get(i) {
3053                    Some(expected_invisible) => match (expected_invisible, actual_invisible) {
3054                        (Invisible::Whitespace { .. }, Invisible::Whitespace { .. })
3055                        | (Invisible::Tab { .. }, Invisible::Tab { .. }) => {}
3056                        _ => {
3057                            panic!("At index {i}, expected invisible {expected_invisible:?} does not match actual {actual_invisible:?} by kind. Actual invisibles: {actual_invisibles:?}")
3058                        }
3059                    },
3060                    None => panic!("Unexpected extra invisible {actual_invisible:?} at index {i}"),
3061                }
3062            }
3063            let missing_expected_invisibles = &expected_invisibles[i + 1..];
3064            assert!(
3065                missing_expected_invisibles.is_empty(),
3066                "Missing expected invisibles after index {i}: {missing_expected_invisibles:?}"
3067            );
3068
3069            editor_width += resize_step;
3070        }
3071    }
3072
3073    fn collect_invisibles_from_new_editor(
3074        cx: &mut TestAppContext,
3075        editor_mode: EditorMode,
3076        input_text: &str,
3077        editor_width: f32,
3078    ) -> Vec<Invisible> {
3079        info!(
3080            "Creating editor with mode {editor_mode:?}, witdh {editor_width} and text '{input_text}'"
3081        );
3082        let (_, editor) = cx.add_window(|cx| {
3083            let buffer = MultiBuffer::build_simple(&input_text, cx);
3084            Editor::new(editor_mode, buffer, None, None, cx)
3085        });
3086
3087        let mut element = EditorElement::new(editor.read_with(cx, |editor, cx| editor.style(cx)));
3088        let (_, layout_state) = editor.update(cx, |editor, cx| {
3089            editor.set_soft_wrap_mode(language_settings::SoftWrap::EditorWidth, cx);
3090            editor.set_wrap_width(Some(editor_width), cx);
3091
3092            let mut new_parents = Default::default();
3093            let mut notify_views_if_parents_change = Default::default();
3094            let mut layout_cx = LayoutContext::new(
3095                cx,
3096                &mut new_parents,
3097                &mut notify_views_if_parents_change,
3098                false,
3099            );
3100            element.layout(
3101                SizeConstraint::new(vec2f(editor_width, 500.), vec2f(editor_width, 500.)),
3102                editor,
3103                &mut layout_cx,
3104            )
3105        });
3106
3107        layout_state
3108            .position_map
3109            .line_layouts
3110            .iter()
3111            .map(|line_with_invisibles| &line_with_invisibles.invisibles)
3112            .flatten()
3113            .cloned()
3114            .collect()
3115    }
3116}