Skip to main content

iced_code_editor/canvas_editor/lsp/process/
overlay.rs

1//! LSP overlay UI components for displaying hover tooltips and completion menus.
2//!
3//! Provides [`LspOverlayState`] for storing overlay display state and
4//! [`view_lsp_overlay`] for rendering it on top of a [`CodeEditor`].
5
6use crate::CodeEditor;
7use iced::widget::{
8    Id, Space, button, column, container, markdown, mouse_area, row,
9    scrollable, stack, text,
10};
11use iced::{Background, Border, Color, Element, Length, Point, Shadow, Theme};
12
13/// Maximum number of completion items shown at once in the menu.
14const MAX_COMPLETION_ITEMS: usize = 8;
15/// Height in pixels of each completion item row.
16const COMPLETION_ITEM_HEIGHT: f32 = 20.0;
17/// Height in pixels of the completion menu header area.
18const COMPLETION_HEADER_HEIGHT: f32 = 24.0;
19/// Padding in pixels around the completion item list.
20const COMPLETION_PADDING: f32 = 4.0;
21/// Maximum width in pixels of the completion menu.
22const COMPLETION_MENU_WIDTH: f32 = 250.0;
23/// Border radius in pixels applied to scrollable rail and scroller borders.
24const SCROLLABLE_BORDER_RADIUS: f32 = 4.0;
25
26/// State for the LSP overlay display (hover tooltips and completion menus).
27///
28/// This struct aggregates all display-related LSP state. Instantiate once in
29/// your application and pass it to [`view_lsp_overlay`] for rendering.
30///
31/// # Example
32///
33/// ```
34/// use iced_code_editor::LspOverlayState;
35///
36/// let mut state = LspOverlayState::new();
37/// assert!(!state.hover_visible);
38/// assert!(!state.completion_visible);
39/// ```
40pub struct LspOverlayState {
41    /// The hover text received from the LSP server.
42    pub hover_text: Option<String>,
43    /// Parsed markdown items derived from `hover_text`.
44    pub hover_items: Vec<iced::widget::markdown::Item>,
45    /// Whether the hover tooltip is currently visible.
46    pub hover_visible: bool,
47    /// Screen position where the hover tooltip should be rendered.
48    pub hover_position: Option<Point>,
49    /// Whether the mouse cursor is currently over the hover tooltip.
50    pub hover_interactive: bool,
51    /// All completion items received from the LSP server.
52    pub all_completions: Vec<String>,
53    /// Current filter string applied to completion items.
54    pub completion_filter: String,
55    /// Filtered completion items to display.
56    pub completion_items: Vec<String>,
57    /// Whether the completion menu is currently visible.
58    pub completion_visible: bool,
59    /// Index of the currently selected completion item.
60    pub completion_selected: usize,
61    /// Whether completion has been suppressed after applying an item.
62    pub completion_suppressed: bool,
63    /// Screen position of the completion menu anchor.
64    pub completion_position: Option<Point>,
65}
66
67impl LspOverlayState {
68    /// Creates a new [`LspOverlayState`] with all fields at their default values.
69    ///
70    /// # Example
71    ///
72    /// ```
73    /// use iced_code_editor::LspOverlayState;
74    ///
75    /// let state = LspOverlayState::new();
76    /// assert!(!state.hover_visible);
77    /// assert!(!state.completion_visible);
78    /// ```
79    pub fn new() -> Self {
80        Self {
81            hover_text: None,
82            hover_items: Vec::new(),
83            hover_visible: false,
84            hover_position: None,
85            hover_interactive: false,
86            all_completions: Vec::new(),
87            completion_filter: String::new(),
88            completion_items: Vec::new(),
89            completion_visible: false,
90            completion_selected: 0,
91            completion_suppressed: false,
92            completion_position: None,
93        }
94    }
95
96    /// Sets the screen position where the hover tooltip should appear.
97    ///
98    /// Call this when dispatching a hover request to the LSP server.
99    ///
100    /// # Example
101    ///
102    /// ```
103    /// use iced::Point;
104    /// use iced_code_editor::LspOverlayState;
105    ///
106    /// let mut state = LspOverlayState::new();
107    /// state.set_hover_position(Point::new(100.0, 200.0));
108    /// assert_eq!(state.hover_position, Some(Point::new(100.0, 200.0)));
109    /// ```
110    pub fn set_hover_position(&mut self, point: Point) {
111        self.hover_position = Some(point);
112    }
113
114    /// Displays a hover tooltip with the given text.
115    ///
116    /// Parses the text as markdown and marks the tooltip as visible.
117    ///
118    /// # Example
119    ///
120    /// ```
121    /// use iced_code_editor::LspOverlayState;
122    ///
123    /// let mut state = LspOverlayState::new();
124    /// state.show_hover("**bold** text".to_string());
125    /// assert!(state.hover_visible);
126    /// assert!(state.hover_text.is_some());
127    /// ```
128    pub fn show_hover(&mut self, text: String) {
129        self.hover_items = iced::widget::markdown::parse(&text).collect();
130        self.hover_text = Some(text);
131        self.hover_visible = true;
132    }
133
134    /// Clears all hover-related state.
135    ///
136    /// Resets hover text, items, visibility, position, and interaction flags.
137    ///
138    /// # Example
139    ///
140    /// ```
141    /// use iced_code_editor::LspOverlayState;
142    ///
143    /// let mut state = LspOverlayState::new();
144    /// state.show_hover("some text".to_string());
145    /// state.clear_hover();
146    /// assert!(!state.hover_visible);
147    /// assert!(state.hover_text.is_none());
148    /// ```
149    pub fn clear_hover(&mut self) {
150        self.hover_text = None;
151        self.hover_items.clear();
152        self.hover_visible = false;
153        self.hover_position = None;
154        self.hover_interactive = false;
155    }
156
157    /// Sets the completion items and their display position.
158    ///
159    /// Resets the selection to index 0 and applies the current filter.
160    ///
161    /// # Example
162    ///
163    /// ```
164    /// use iced::Point;
165    /// use iced_code_editor::LspOverlayState;
166    ///
167    /// let mut state = LspOverlayState::new();
168    /// state.set_completions(
169    ///     vec!["foo".to_string(), "bar".to_string()],
170    ///     Point::ORIGIN,
171    /// );
172    /// assert_eq!(state.completion_items.len(), 2);
173    /// ```
174    pub fn set_completions(&mut self, items: Vec<String>, position: Point) {
175        self.all_completions = items;
176        self.completion_selected = 0;
177        self.completion_position = Some(position);
178        self.filter_completions();
179    }
180
181    /// Clears all completion-related state.
182    ///
183    /// # Example
184    ///
185    /// ```
186    /// use iced::Point;
187    /// use iced_code_editor::LspOverlayState;
188    ///
189    /// let mut state = LspOverlayState::new();
190    /// state.set_completions(vec!["foo".to_string()], Point::ORIGIN);
191    /// state.clear_completions();
192    /// assert!(!state.completion_visible);
193    /// assert!(state.all_completions.is_empty());
194    /// ```
195    pub fn clear_completions(&mut self) {
196        self.all_completions.clear();
197        self.completion_items.clear();
198        self.completion_filter.clear();
199        self.completion_visible = false;
200        self.completion_suppressed = false;
201    }
202
203    /// Filters `all_completions` into `completion_items` using `completion_filter`.
204    ///
205    /// Updates `completion_visible` and clamps `completion_selected` if needed.
206    ///
207    /// # Example
208    ///
209    /// ```
210    /// use iced::Point;
211    /// use iced_code_editor::LspOverlayState;
212    ///
213    /// let mut state = LspOverlayState::new();
214    /// state.set_completions(
215    ///     vec!["foo".to_string(), "bar".to_string()],
216    ///     Point::ORIGIN,
217    /// );
218    /// state.completion_filter = "fo".to_string();
219    /// state.filter_completions();
220    /// assert_eq!(state.completion_items, vec!["foo".to_string()]);
221    /// ```
222    pub fn filter_completions(&mut self) {
223        let filter = self.completion_filter.to_lowercase();
224        if filter.is_empty() {
225            self.completion_items = self.all_completions.clone();
226        } else {
227            self.completion_items = self
228                .all_completions
229                .iter()
230                .filter(|item| item.to_lowercase().contains(&filter))
231                .cloned()
232                .collect();
233        }
234        self.completion_visible = !self.completion_items.is_empty();
235        if self.completion_selected >= self.completion_items.len() {
236            self.completion_selected =
237                self.completion_items.len().saturating_sub(1);
238        }
239    }
240
241    /// Navigates through the completion list by `delta` steps, wrapping at boundaries.
242    ///
243    /// # Example
244    ///
245    /// ```
246    /// use iced::Point;
247    /// use iced_code_editor::LspOverlayState;
248    ///
249    /// let mut state = LspOverlayState::new();
250    /// state.set_completions(
251    ///     vec!["a".to_string(), "b".to_string(), "c".to_string()],
252    ///     Point::ORIGIN,
253    /// );
254    /// state.navigate(1);
255    /// assert_eq!(state.completion_selected, 1);
256    /// state.navigate(-1);
257    /// assert_eq!(state.completion_selected, 0);
258    /// ```
259    pub fn navigate(&mut self, delta: i32) {
260        if self.completion_items.is_empty() {
261            return;
262        }
263        let len = self.completion_items.len();
264        let current = self.completion_selected as i32;
265        self.completion_selected =
266            ((current + delta).rem_euclid(len as i32)) as usize;
267    }
268
269    /// Returns the currently selected completion item, if any.
270    ///
271    /// # Example
272    ///
273    /// ```
274    /// use iced::Point;
275    /// use iced_code_editor::LspOverlayState;
276    ///
277    /// let mut state = LspOverlayState::new();
278    /// state.set_completions(vec!["foo".to_string()], Point::ORIGIN);
279    /// assert_eq!(state.selected_item(), Some("foo"));
280    /// ```
281    pub fn selected_item(&self) -> Option<&str> {
282        self.completion_items.get(self.completion_selected).map(String::as_str)
283    }
284
285    /// Returns the vertical scroll offset in pixels to keep the selected
286    /// completion item visible when navigating with the keyboard.
287    ///
288    /// Pass the returned value to `scrollable::AbsoluteOffset::y`.
289    ///
290    /// # Example
291    ///
292    /// ```
293    /// use iced::Point;
294    /// use iced_code_editor::LspOverlayState;
295    ///
296    /// let mut state = LspOverlayState::new();
297    /// state.set_completions(
298    ///     vec!["a".to_string(), "b".to_string(), "c".to_string()],
299    ///     Point::ORIGIN,
300    /// );
301    /// state.navigate(2);
302    /// assert_eq!(state.scroll_offset_for_selected(), 40.0);
303    /// ```
304    pub fn scroll_offset_for_selected(&self) -> f32 {
305        self.completion_selected as f32 * COMPLETION_ITEM_HEIGHT
306    }
307}
308
309impl Default for LspOverlayState {
310    fn default() -> Self {
311        Self::new()
312    }
313}
314
315/// Messages produced by LSP overlay UI interactions.
316///
317/// Use these in your application's `update` function to handle hover
318/// and completion interactions, driving [`LspOverlayState`] with the matching
319/// method ([`LspOverlayState::navigate`], [`LspOverlayState::clear_completions`],
320/// and friends). The keyboard variants let a host route Up/Down/Enter to the
321/// completion menu while it is open, instead of to the editor.
322///
323/// # Examples
324///
325/// ```
326/// use iced::Point;
327/// use iced_code_editor::{LspOverlayMessage, LspOverlayState};
328///
329/// let mut state = LspOverlayState::new();
330/// state.set_completions(
331///     vec!["main".to_string(), "map".to_string()],
332///     Point::ORIGIN,
333/// );
334///
335/// // Route the keyboard variants to the overlay while the menu is open.
336/// let selected = match LspOverlayMessage::CompletionNavigateDown {
337///     LspOverlayMessage::CompletionNavigateDown => {
338///         state.navigate(1);
339///         state.selected_item()
340///     }
341///     LspOverlayMessage::CompletionNavigateUp => {
342///         state.navigate(-1);
343///         state.selected_item()
344///     }
345///     _ => None,
346/// };
347/// assert_eq!(selected, Some("map"));
348///
349/// // Dismissing clears the menu.
350/// state.clear_completions();
351/// assert!(!state.completion_visible);
352/// ```
353#[derive(Debug, Clone)]
354pub enum LspOverlayMessage {
355    /// The mouse cursor entered the hover tooltip area.
356    HoverEntered,
357    /// The mouse cursor exited the hover tooltip area.
358    HoverExited,
359    /// A completion item at the given index was clicked.
360    CompletionSelected(usize),
361    /// The completion menu was dismissed by clicking outside it.
362    CompletionClosed,
363    /// Navigate up in the completion list (e.g., keyboard Up arrow).
364    CompletionNavigateUp,
365    /// Navigate down in the completion list (e.g., keyboard Down arrow).
366    CompletionNavigateDown,
367    /// Confirm the currently highlighted completion item (e.g., Enter key).
368    CompletionConfirm,
369}
370
371/// Measures the maximum pixel width of any line in the given text.
372///
373/// A hover tooltip is as wide as its widest line, so the whole text is
374/// measured line by line rather than as one string — measuring it whole would
375/// return the sum of every line's width. Measurement goes through the editor's
376/// own metrics, so a CJK line is measured at its real double width.
377///
378/// # Arguments
379///
380/// * `editor` - The editor whose font metrics measure the text
381/// * `text` - The hover text, possibly spanning several lines
382///
383/// # Returns
384///
385/// The width in pixels of the widest line, or `0.0` when `text` is empty
386fn measure_hover_width(editor: &CodeEditor, text: &str) -> f32 {
387    text.lines().map(|line| editor.measure_text_width(line)).fold(0.0, f32::max)
388}
389
390/// Renders LSP overlay elements (hover tooltip and completion menu) on top of a [`CodeEditor`].
391///
392/// Returns an [`Element`] containing the overlays positioned relative to the editor viewport.
393/// The function maps [`LspOverlayMessage`] values to the application message type `M` via `f`.
394///
395/// # Arguments
396///
397/// * `state` — current overlay display state
398/// * `editor` — the editor this overlay is associated with (used for viewport measurements)
399/// * `theme` — the active Iced theme for styling
400/// * `font_size` — font size in points, used for markdown rendering
401/// * `line_height` — line height in pixels, used for vertical positioning
402/// * `f` — mapping function from [`LspOverlayMessage`] to the app's message type
403///
404/// # Example
405///
406/// ```no_run
407/// use iced_code_editor::{
408///     CodeEditor, LspOverlayMessage, LspOverlayState, view_lsp_overlay,
409/// };
410///
411/// struct App {
412///     editor: CodeEditor,
413///     overlay: LspOverlayState,
414/// }
415///
416/// #[derive(Clone)]
417/// enum Message {
418///     Overlay(LspOverlayMessage),
419/// }
420///
421/// fn view(app: &App) -> iced::Element<'_, Message> {
422///     view_lsp_overlay(
423///         &app.overlay,
424///         &app.editor,
425///         &iced::Theme::Dark,
426///         14.0,
427///         20.0,
428///         Message::Overlay,
429///     )
430/// }
431/// ```
432pub fn view_lsp_overlay<'a, M: Clone + 'a>(
433    state: &'a LspOverlayState,
434    editor: &'a CodeEditor,
435    theme: &'a Theme,
436    font_size: f32,
437    line_height: f32,
438    f: impl Fn(LspOverlayMessage) -> M + 'a,
439) -> Element<'a, M> {
440    // Pre-compute messages so we can clone them freely
441    let msg_hover_entered = f(LspOverlayMessage::HoverEntered);
442    let msg_hover_exited = f(LspOverlayMessage::HoverExited);
443    let msg_completion_closed = f(LspOverlayMessage::CompletionClosed);
444    let msg_completion_selected: Vec<M> = (0..state.completion_items.len())
445        .map(|i| f(LspOverlayMessage::CompletionSelected(i)))
446        .collect();
447
448    let mut has_overlay = false;
449
450    // Build the hover tooltip layer
451    let hover_layer: Element<'a, M> = build_hover_layer(
452        state,
453        editor,
454        theme,
455        (font_size, line_height),
456        msg_hover_entered,
457        msg_hover_exited,
458        &mut has_overlay,
459    );
460
461    // Build the auto-completion menu layer
462    let completion_layer: Element<'a, M> = build_completion_layer(
463        state,
464        editor,
465        line_height,
466        msg_completion_closed,
467        msg_completion_selected,
468        &mut has_overlay,
469    );
470
471    if !has_overlay {
472        return container(
473            Space::new().width(Length::Shrink).height(Length::Shrink),
474        )
475        .into();
476    }
477
478    let base = container(Space::new().width(Length::Fill).height(Length::Fill))
479        .width(Length::Fill)
480        .height(Length::Fill);
481
482    // Hover appears on top of completion
483    stack![base, completion_layer, hover_layer].into()
484}
485
486/// Builds the hover tooltip layer.
487fn build_hover_layer<'a, M: Clone + 'a>(
488    state: &'a LspOverlayState,
489    editor: &'a CodeEditor,
490    theme: &'a Theme,
491    text_metrics: (f32, f32),
492    msg_entered: M,
493    msg_exited: M,
494    has_overlay: &mut bool,
495) -> Element<'a, M> {
496    let (font_size, line_height) = text_metrics;
497    if !state.hover_visible {
498        return empty_overlay();
499    }
500
501    let Some(hover) =
502        state.hover_text.as_ref().filter(|t| !t.trim().is_empty())
503    else {
504        return empty_overlay();
505    };
506
507    let line_count = hover.lines().count().max(1);
508    let visible_lines = line_count.min(10);
509    let hover_padding = 8.0;
510    let scroll_height = line_height * visible_lines as f32
511        + (line_height * 0.75).max(10.0)
512        + hover_padding * 2.0;
513
514    let viewport_width = editor.viewport_width();
515    let max_line_width = measure_hover_width(editor, hover);
516    let max_width = (viewport_width - 24.0).max(0.0);
517    let content_max_width = if max_width > hover_padding * 2.0 {
518        max_width - hover_padding * 2.0
519    } else {
520        max_width
521    };
522    let content_width = if content_max_width > 0.0 {
523        max_line_width.min(content_max_width)
524    } else {
525        max_line_width
526    };
527    let hover_width = content_width + hover_padding * 2.0;
528
529    let palette = theme.palette();
530    let markdown_settings = markdown::Settings::with_text_size(
531        font_size,
532        markdown::Style::from_palette(palette),
533    );
534
535    let entered_for_map = msg_entered.clone();
536    let entered_for_enter = msg_entered.clone();
537    let entered_for_move = msg_entered;
538
539    let hover_content = scrollable(
540        container(
541            markdown::view(&state.hover_items, markdown_settings)
542                .map(move |_| entered_for_map.clone()),
543        )
544        .width(Length::Fixed(hover_width))
545        .padding(hover_padding),
546    )
547    .height(Length::Fixed(scroll_height))
548    .width(Length::Fixed(hover_width))
549    .style(|theme: &Theme, _status| {
550        let palette = theme.extended_palette();
551        scrollable::Style {
552            container: container::Style {
553                background: Some(Background::Color(Color::TRANSPARENT)),
554                ..container::Style::default()
555            },
556            vertical_rail: lsp_scrollable_rail(palette),
557            horizontal_rail: lsp_scrollable_rail(palette),
558            gap: None,
559            auto_scroll: scrollable::AutoScroll {
560                background: Color::TRANSPARENT.into(),
561                border: Border::default(),
562                shadow: Shadow::default(),
563                icon: Color::TRANSPARENT,
564            },
565        }
566    });
567
568    let hover_box = container(column![hover_content])
569        .width(Length::Shrink)
570        .style(|theme: &Theme| {
571            let palette = theme.extended_palette();
572            container::Style {
573                background: Some(iced::Background::Color(
574                    palette.background.weak.color,
575                )),
576                border: iced::Border {
577                    color: palette.primary.weak.color,
578                    width: 1.0,
579                    radius: 6.0.into(),
580                },
581                ..Default::default()
582            }
583        });
584
585    let hover_box: Element<'_, M> = mouse_area(hover_box)
586        .on_enter(entered_for_enter)
587        .on_move(move |_| entered_for_move.clone())
588        .on_exit(msg_exited)
589        .into();
590
591    let hover_pos = state.hover_position.unwrap_or(Point::new(4.0, 4.0));
592    let viewport_scroll = editor.viewport_scroll();
593    let hover_pos =
594        Point::new(hover_pos.x, (hover_pos.y - viewport_scroll).max(0.0));
595    let viewport_height = editor.viewport_height();
596    let gap = 1.0;
597    let show_above = hover_pos.y >= scroll_height + gap;
598
599    let gap_x = (editor.char_width() * 0.5).max(2.0);
600    let right_x = hover_pos.x + gap_x;
601    let left_x = hover_pos.x - hover_width - gap_x;
602    let max_x = (viewport_width - hover_width - 4.0).max(0.0);
603
604    let offset_x = if right_x <= max_x {
605        right_x
606    } else if left_x >= 0.0 {
607        left_x
608    } else {
609        right_x.clamp(0.0, max_x)
610    };
611
612    let offset_y = if show_above {
613        (hover_pos.y - scroll_height - gap).max(0.0)
614    } else {
615        (hover_pos.y + line_height + gap).max(0.0).min(viewport_height)
616    };
617
618    *has_overlay = true;
619
620    container(
621        column![
622            Space::new().height(Length::Fixed(offset_y)),
623            row![Space::new().width(Length::Fixed(offset_x)), hover_box]
624        ]
625        .spacing(0)
626        .width(Length::Fill)
627        .height(Length::Fill),
628    )
629    .width(Length::Fill)
630    .height(Length::Fill)
631    .into()
632}
633
634/// Builds the auto-completion menu layer.
635fn build_completion_layer<'a, M: Clone + 'a>(
636    state: &'a LspOverlayState,
637    editor: &'a CodeEditor,
638    line_height: f32,
639    msg_closed: M,
640    msg_selected: Vec<M>,
641    has_overlay: &mut bool,
642) -> Element<'a, M> {
643    if !state.completion_visible
644        || state.completion_items.is_empty()
645        || state.completion_suppressed
646    {
647        return empty_overlay();
648    }
649
650    let visible_count = state.completion_items.len().min(MAX_COMPLETION_ITEMS);
651    let menu_height = COMPLETION_HEADER_HEIGHT
652        + (visible_count as f32 * COMPLETION_ITEM_HEIGHT)
653        + (COMPLETION_PADDING * 2.0);
654
655    let cursor_pos = state.completion_position.unwrap_or(Point::new(4.0, 4.0));
656    let viewport_width = editor.viewport_width();
657    let viewport_height = editor.viewport_height();
658    let viewport_scroll = editor.viewport_scroll();
659
660    let menu_width = COMPLETION_MENU_WIDTH.min(viewport_width - 8.0);
661    let adjusted_y = (cursor_pos.y - viewport_scroll).max(0.0);
662    let space_below = viewport_height - adjusted_y - line_height;
663    let show_above =
664        space_below < menu_height + 4.0 && adjusted_y >= menu_height + 4.0;
665
666    let offset_x = cursor_pos.x.min(viewport_width - menu_width - 4.0).max(4.0);
667    let offset_y = if show_above {
668        (adjusted_y - menu_height - 4.0).max(0.0)
669    } else {
670        adjusted_y + line_height + 4.0
671    };
672
673    let completion_elements: Vec<Element<'_, M>> = state
674        .completion_items
675        .iter()
676        .enumerate()
677        .zip(msg_selected)
678        .map(|((index, item), msg)| {
679            let is_selected = index == state.completion_selected;
680            button(
681                text(item.clone())
682                    .size(12)
683                    .line_height(iced::widget::text::LineHeight::Relative(1.5)),
684            )
685            .padding([2, 8])
686            .width(Length::Fill)
687            .on_press(msg)
688            .style(move |theme: &Theme, _status| {
689                let palette = theme.extended_palette();
690                if is_selected {
691                    button::Style {
692                        background: Some(iced::Background::Color(
693                            palette.primary.weak.color,
694                        )),
695                        text_color: Color::WHITE,
696                        ..Default::default()
697                    }
698                } else {
699                    button::Style {
700                        background: Some(iced::Background::Color(
701                            palette.background.weak.color,
702                        )),
703                        text_color: Color::WHITE,
704                        ..Default::default()
705                    }
706                }
707            })
708            .into()
709        })
710        .collect();
711
712    let completion_box = scrollable(column(completion_elements).spacing(0))
713        .height(Length::Fixed(menu_height))
714        .width(Length::Fixed(menu_width))
715        .id(Id::new("completion_scrollable"))
716        .style(|theme: &Theme, _status| {
717            let palette = theme.extended_palette();
718            scrollable::Style {
719                container: container::Style {
720                    background: Some(iced::Background::Color(
721                        palette.background.weak.color,
722                    )),
723                    border: iced::Border {
724                        color: palette.primary.weak.color,
725                        width: 1.0,
726                        radius: SCROLLABLE_BORDER_RADIUS.into(),
727                    },
728                    ..Default::default()
729                },
730                vertical_rail: lsp_scrollable_rail(palette),
731                horizontal_rail: lsp_scrollable_rail(palette),
732                gap: None,
733                auto_scroll: scrollable::AutoScroll {
734                    background: Color::TRANSPARENT.into(),
735                    border: Border::default(),
736                    shadow: Shadow::default(),
737                    icon: Color::TRANSPARENT,
738                },
739            }
740        });
741
742    *has_overlay = true;
743
744    let click_outside =
745        button(Space::new().width(Length::Fill).height(Length::Fill))
746            .width(Length::Fill)
747            .height(Length::Fill)
748            .on_press(msg_closed)
749            .style(|_theme: &Theme, _status| button::Style {
750                background: Some(Background::Color(Color::TRANSPARENT)),
751                ..Default::default()
752            });
753
754    let completion_content = container(
755        column![
756            Space::new().height(Length::Fixed(offset_y)),
757            row![Space::new().width(Length::Fixed(offset_x)), completion_box]
758        ]
759        .spacing(0)
760        .width(Length::Fill)
761        .height(Length::Fill),
762    )
763    .width(Length::Fill)
764    .height(Length::Fill);
765
766    stack![click_outside, completion_content].into()
767}
768
769/// Creates the scrollable rail style used in LSP overlay panels.
770///
771/// Both the hover tooltip and the completion menu share the same rail appearance:
772/// a translucent background track with a primary-coloured scroller and no border.
773fn lsp_scrollable_rail(
774    palette: &iced::theme::palette::Extended,
775) -> scrollable::Rail {
776    crate::canvas_editor::render::view::scrollable_rail(
777        palette.background.weak.color,
778        palette.primary.weak.color,
779        SCROLLABLE_BORDER_RADIUS,
780    )
781}
782
783/// Returns a zero-size placeholder element.
784fn empty_overlay<'a, M: 'a>() -> Element<'a, M> {
785    container(Space::new().width(Length::Shrink).height(Length::Shrink)).into()
786}
787
788#[cfg(test)]
789mod tests {
790    use super::*;
791    use iced::Point;
792
793    /// Asserts two widths are equal within the layout epsilon, since
794    /// `float_cmp` is denied crate-wide.
795    fn assert_same_width(measured: f32, expected: f32) {
796        assert_eq!(
797            crate::canvas_editor::compare_floats(measured, expected),
798            std::cmp::Ordering::Equal,
799            "expected {expected}, measured {measured}"
800        );
801    }
802
803    #[test]
804    fn test_hover_width_is_the_widest_line_not_the_first_or_the_last() {
805        // The tooltip has to fit its widest line. Measuring the text as one
806        // string would sum every line instead, and taking the first or last
807        // line would clip the others -- the middle line is the widest here so
808        // all three mistakes are distinguishable.
809        let editor = CodeEditor::new("", "rs");
810        let text = "fn a()\nfn a_much_longer_signature()\nfn b()";
811
812        assert_same_width(
813            measure_hover_width(&editor, text),
814            editor.measure_text_width("fn a_much_longer_signature()"),
815        );
816    }
817
818    #[test]
819    fn test_hover_width_of_a_single_line_is_that_line() {
820        let editor = CodeEditor::new("", "rs");
821
822        assert_same_width(
823            measure_hover_width(&editor, "fn main()"),
824            editor.measure_text_width("fn main()"),
825        );
826    }
827
828    #[test]
829    fn test_hover_width_of_empty_text_is_zero() {
830        // `"".lines()` yields nothing, so the fold returns its seed. Pinned
831        // because a tooltip sized from a `NEG_INFINITY` seed would not render.
832        let editor = CodeEditor::new("", "rs");
833
834        assert_same_width(measure_hover_width(&editor, ""), 0.0);
835    }
836
837    #[test]
838    fn test_lsp_overlay_state_new() {
839        let state = LspOverlayState::new();
840        assert!(!state.hover_visible);
841        assert!(!state.completion_visible);
842        assert!(state.hover_text.is_none());
843        assert!(state.completion_items.is_empty());
844    }
845
846    #[test]
847    fn test_show_hover() {
848        let mut state = LspOverlayState::new();
849        state.show_hover("hello".to_string());
850        assert!(state.hover_visible);
851        assert_eq!(state.hover_text, Some("hello".to_string()));
852    }
853
854    #[test]
855    fn test_clear_hover() {
856        let mut state = LspOverlayState::new();
857        state.show_hover("hello".to_string());
858        state.hover_interactive = true;
859        state.hover_position = Some(Point::ORIGIN);
860        state.clear_hover();
861        assert!(!state.hover_visible);
862        assert!(state.hover_text.is_none());
863        assert!(!state.hover_interactive);
864        assert!(state.hover_position.is_none());
865    }
866
867    #[test]
868    fn test_set_hover_position() {
869        let mut state = LspOverlayState::new();
870        state.set_hover_position(Point::new(10.0, 20.0));
871        assert_eq!(state.hover_position, Some(Point::new(10.0, 20.0)));
872    }
873
874    #[test]
875    fn test_set_completions() {
876        let mut state = LspOverlayState::new();
877        state.set_completions(
878            vec!["foo".to_string(), "bar".to_string()],
879            Point::ORIGIN,
880        );
881        assert_eq!(state.completion_items.len(), 2);
882        assert!(state.completion_visible);
883        assert_eq!(state.completion_selected, 0);
884    }
885
886    #[test]
887    fn test_clear_completions() {
888        let mut state = LspOverlayState::new();
889        state.set_completions(vec!["foo".to_string()], Point::ORIGIN);
890        state.clear_completions();
891        assert!(!state.completion_visible);
892        assert!(state.all_completions.is_empty());
893        assert!(state.completion_items.is_empty());
894    }
895
896    #[test]
897    fn test_filter_completions() {
898        let mut state = LspOverlayState::new();
899        state.set_completions(
900            vec!["foo".to_string(), "bar".to_string(), "baz".to_string()],
901            Point::ORIGIN,
902        );
903        state.completion_filter = "ba".to_string();
904        state.filter_completions();
905        assert_eq!(state.completion_items.len(), 2);
906        assert!(state.completion_items.contains(&"bar".to_string()));
907        assert!(state.completion_items.contains(&"baz".to_string()));
908    }
909
910    #[test]
911    fn test_navigate() {
912        let mut state = LspOverlayState::new();
913        state.set_completions(
914            vec!["a".to_string(), "b".to_string(), "c".to_string()],
915            Point::ORIGIN,
916        );
917        state.navigate(1);
918        assert_eq!(state.completion_selected, 1);
919        state.navigate(-1);
920        assert_eq!(state.completion_selected, 0);
921        // Wrap around going up
922        state.navigate(-1);
923        assert_eq!(state.completion_selected, 2);
924        // Wrap around going down
925        state.navigate(1);
926        assert_eq!(state.completion_selected, 0);
927    }
928
929    #[test]
930    // The asserted offsets are `0.0` and exact multiples of
931    // `COMPLETION_ITEM_HEIGHT` produced by a single multiplication, never by
932    // accumulation, so they are bit-for-bit reproducible. An epsilon
933    // comparison here would hide that exactness rather than protect anything.
934    #[allow(clippy::float_cmp)]
935    fn test_scroll_offset_for_selected() {
936        let mut state = LspOverlayState::new();
937        assert_eq!(state.scroll_offset_for_selected(), 0.0);
938        state.set_completions(
939            vec!["a".to_string(), "b".to_string(), "c".to_string()],
940            Point::ORIGIN,
941        );
942        assert_eq!(state.scroll_offset_for_selected(), 0.0);
943        state.navigate(1);
944        assert_eq!(state.scroll_offset_for_selected(), COMPLETION_ITEM_HEIGHT);
945        state.navigate(1);
946        assert_eq!(
947            state.scroll_offset_for_selected(),
948            2.0 * COMPLETION_ITEM_HEIGHT
949        );
950    }
951
952    #[test]
953    fn test_selected_item() {
954        let mut state = LspOverlayState::new();
955        assert_eq!(state.selected_item(), None);
956        state.set_completions(
957            vec!["first".to_string(), "second".to_string()],
958            Point::ORIGIN,
959        );
960        assert_eq!(state.selected_item(), Some("first"));
961        state.navigate(1);
962        assert_eq!(state.selected_item(), Some("second"));
963    }
964}