1pub mod html;
2mod mermaid;
3pub mod parser;
4mod path_range;
5
6use base64::Engine as _;
7use futures::FutureExt as _;
8use gpui::EdgesRefinement;
9use gpui::HitboxBehavior;
10use gpui::UnderlineStyle;
11use language::LanguageName;
12
13use log::Level;
14use mermaid::{
15 MermaidState, ParsedMarkdownMermaidDiagram, extract_mermaid_diagrams, render_mermaid_diagram,
16};
17pub use path_range::{LineCol, PathWithRange};
18use settings::Settings as _;
19use theme_settings::ThemeSettings;
20use ui::Checkbox;
21use ui::CopyButton;
22
23use std::borrow::Cow;
24use std::collections::BTreeMap;
25use std::iter;
26use std::mem;
27use std::ops::Range;
28use std::path::Path;
29use std::rc::Rc;
30use std::sync::Arc;
31use std::time::Duration;
32
33use collections::{HashMap, HashSet};
34use gpui::{
35 AnyElement, App, BorderStyle, Bounds, ClipboardItem, CursorStyle, DispatchPhase, Edges, Entity,
36 FocusHandle, Focusable, FontStyle, FontWeight, GlobalElementId, Hitbox, Hsla, Image,
37 ImageFormat, ImageSource, KeyContext, Length, MouseButton, MouseDownEvent, MouseEvent,
38 MouseMoveEvent, MouseUpEvent, Point, ScrollHandle, Stateful, StrikethroughStyle,
39 StyleRefinement, StyledText, Task, TextLayout, TextRun, TextStyle, TextStyleRefinement,
40 actions, img, point, quad,
41};
42use language::{CharClassifier, Language, LanguageRegistry, Rope};
43use parser::CodeBlockMetadata;
44use parser::{
45 MarkdownEvent, MarkdownTag, MarkdownTagEnd, parse_links_only, parse_markdown_with_options,
46};
47use pulldown_cmark::Alignment;
48use sum_tree::TreeMap;
49use theme::SyntaxTheme;
50use ui::{ScrollAxes, Scrollbars, WithScrollbar, prelude::*};
51use util::ResultExt;
52
53use crate::parser::CodeBlockKind;
54
55/// A callback function that can be used to customize the style of links based on the destination URL.
56/// If the callback returns `None`, the default link style will be used.
57type LinkStyleCallback = Rc<dyn Fn(&str, &App) -> Option<TextStyleRefinement>>;
58type SourceClickCallback = Box<dyn Fn(usize, usize, &mut Window, &mut App) -> bool>;
59type CheckboxToggleCallback = Rc<dyn Fn(Range<usize>, bool, &mut Window, &mut App)>;
60/// Defines custom style refinements for each heading level (H1-H6)
61#[derive(Clone, Default)]
62pub struct HeadingLevelStyles {
63 pub h1: Option<TextStyleRefinement>,
64 pub h2: Option<TextStyleRefinement>,
65 pub h3: Option<TextStyleRefinement>,
66 pub h4: Option<TextStyleRefinement>,
67 pub h5: Option<TextStyleRefinement>,
68 pub h6: Option<TextStyleRefinement>,
69}
70
71#[derive(Clone)]
72pub struct MarkdownStyle {
73 pub base_text_style: TextStyle,
74 pub container_style: StyleRefinement,
75 pub code_block: StyleRefinement,
76 pub code_block_overflow_x_scroll: bool,
77 pub inline_code: TextStyleRefinement,
78 pub block_quote: TextStyleRefinement,
79 pub link: TextStyleRefinement,
80 pub link_callback: Option<LinkStyleCallback>,
81 pub rule_color: Hsla,
82 pub block_quote_border_color: Hsla,
83 pub syntax: Arc<SyntaxTheme>,
84 pub selection_background_color: Hsla,
85 pub heading: StyleRefinement,
86 pub heading_level_styles: Option<HeadingLevelStyles>,
87 pub height_is_multiple_of_line_height: bool,
88 pub prevent_mouse_interaction: bool,
89 pub table_columns_min_size: bool,
90}
91
92impl Default for MarkdownStyle {
93 fn default() -> Self {
94 Self {
95 base_text_style: Default::default(),
96 container_style: Default::default(),
97 code_block: Default::default(),
98 code_block_overflow_x_scroll: false,
99 inline_code: Default::default(),
100 block_quote: Default::default(),
101 link: Default::default(),
102 link_callback: None,
103 rule_color: Default::default(),
104 block_quote_border_color: Default::default(),
105 syntax: Arc::new(SyntaxTheme::default()),
106 selection_background_color: Default::default(),
107 heading: Default::default(),
108 heading_level_styles: None,
109 height_is_multiple_of_line_height: false,
110 prevent_mouse_interaction: false,
111 table_columns_min_size: false,
112 }
113 }
114}
115
116pub enum MarkdownFont {
117 Agent,
118 Editor,
119}
120
121impl MarkdownStyle {
122 pub fn themed(font: MarkdownFont, window: &Window, cx: &App) -> Self {
123 let theme_settings = ThemeSettings::get_global(cx);
124 let colors = cx.theme().colors();
125
126 let buffer_font_weight = theme_settings.buffer_font.weight;
127 let (buffer_font_size, ui_font_size) = match font {
128 MarkdownFont::Agent => (
129 theme_settings.agent_buffer_font_size(cx),
130 theme_settings.agent_ui_font_size(cx),
131 ),
132 MarkdownFont::Editor => (
133 theme_settings.buffer_font_size(cx),
134 theme_settings.ui_font_size(cx),
135 ),
136 };
137
138 let text_color = colors.text;
139
140 let mut text_style = window.text_style();
141 let line_height = buffer_font_size * 1.75;
142
143 text_style.refine(&TextStyleRefinement {
144 font_family: Some(theme_settings.ui_font.family.clone()),
145 font_fallbacks: theme_settings.ui_font.fallbacks.clone(),
146 font_features: Some(theme_settings.ui_font.features.clone()),
147 font_size: Some(ui_font_size.into()),
148 line_height: Some(line_height.into()),
149 color: Some(text_color),
150 ..Default::default()
151 });
152
153 MarkdownStyle {
154 base_text_style: text_style.clone(),
155 syntax: cx.theme().syntax().clone(),
156 selection_background_color: colors.element_selection_background,
157 code_block_overflow_x_scroll: true,
158 heading_level_styles: Some(HeadingLevelStyles {
159 h1: Some(TextStyleRefinement {
160 font_size: Some(rems(1.15).into()),
161 ..Default::default()
162 }),
163 h2: Some(TextStyleRefinement {
164 font_size: Some(rems(1.1).into()),
165 ..Default::default()
166 }),
167 h3: Some(TextStyleRefinement {
168 font_size: Some(rems(1.05).into()),
169 ..Default::default()
170 }),
171 h4: Some(TextStyleRefinement {
172 font_size: Some(rems(1.).into()),
173 ..Default::default()
174 }),
175 h5: Some(TextStyleRefinement {
176 font_size: Some(rems(0.95).into()),
177 ..Default::default()
178 }),
179 h6: Some(TextStyleRefinement {
180 font_size: Some(rems(0.875).into()),
181 ..Default::default()
182 }),
183 }),
184 code_block: StyleRefinement {
185 padding: EdgesRefinement {
186 top: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(8.)))),
187 left: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(8.)))),
188 right: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(8.)))),
189 bottom: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(8.)))),
190 },
191 margin: EdgesRefinement {
192 top: Some(Length::Definite(px(8.).into())),
193 left: Some(Length::Definite(px(0.).into())),
194 right: Some(Length::Definite(px(0.).into())),
195 bottom: Some(Length::Definite(px(12.).into())),
196 },
197 border_style: Some(BorderStyle::Solid),
198 border_widths: EdgesRefinement {
199 top: Some(AbsoluteLength::Pixels(px(1.))),
200 left: Some(AbsoluteLength::Pixels(px(1.))),
201 right: Some(AbsoluteLength::Pixels(px(1.))),
202 bottom: Some(AbsoluteLength::Pixels(px(1.))),
203 },
204 border_color: Some(colors.border_variant),
205 background: Some(colors.editor_background.into()),
206 text: TextStyleRefinement {
207 font_family: Some(theme_settings.buffer_font.family.clone()),
208 font_fallbacks: theme_settings.buffer_font.fallbacks.clone(),
209 font_features: Some(theme_settings.buffer_font.features.clone()),
210 font_size: Some(buffer_font_size.into()),
211 font_weight: Some(buffer_font_weight),
212 ..Default::default()
213 },
214 ..Default::default()
215 },
216 inline_code: TextStyleRefinement {
217 font_family: Some(theme_settings.buffer_font.family.clone()),
218 font_fallbacks: theme_settings.buffer_font.fallbacks.clone(),
219 font_features: Some(theme_settings.buffer_font.features.clone()),
220 font_size: Some(buffer_font_size.into()),
221 font_weight: Some(buffer_font_weight),
222 background_color: Some(colors.editor_foreground.opacity(0.08)),
223 ..Default::default()
224 },
225 link: TextStyleRefinement {
226 background_color: Some(colors.editor_foreground.opacity(0.025)),
227 color: Some(colors.text_accent),
228 underline: Some(UnderlineStyle {
229 color: Some(colors.text_accent.opacity(0.5)),
230 thickness: px(1.),
231 ..Default::default()
232 }),
233 ..Default::default()
234 },
235 ..Default::default()
236 }
237 }
238
239 pub fn with_muted_text(mut self, cx: &App) -> Self {
240 let colors = cx.theme().colors();
241 self.base_text_style.color = colors.text_muted;
242 self
243 }
244}
245
246pub struct Markdown {
247 source: SharedString,
248 selection: Selection,
249 pressed_link: Option<RenderedLink>,
250 autoscroll_request: Option<usize>,
251 active_root_block: Option<usize>,
252 parsed_markdown: ParsedMarkdown,
253 images_by_source_offset: HashMap<usize, Arc<Image>>,
254 should_reparse: bool,
255 pending_parse: Option<Task<()>>,
256 focus_handle: FocusHandle,
257 language_registry: Option<Arc<LanguageRegistry>>,
258 fallback_code_block_language: Option<LanguageName>,
259 options: MarkdownOptions,
260 mermaid_state: MermaidState,
261 copied_code_blocks: HashSet<ElementId>,
262 code_block_scroll_handles: BTreeMap<usize, ScrollHandle>,
263 context_menu_selected_text: Option<String>,
264}
265
266#[derive(Clone, Copy, Default)]
267pub struct MarkdownOptions {
268 pub parse_links_only: bool,
269 pub parse_html: bool,
270 pub render_mermaid_diagrams: bool,
271}
272
273#[derive(Clone, Copy, PartialEq, Eq)]
274pub enum CopyButtonVisibility {
275 Hidden,
276 AlwaysVisible,
277 VisibleOnHover,
278}
279
280pub enum CodeBlockRenderer {
281 Default {
282 copy_button_visibility: CopyButtonVisibility,
283 border: bool,
284 },
285 Custom {
286 render: CodeBlockRenderFn,
287 /// A function that can modify the parent container after the code block
288 /// content has been appended as a child element.
289 transform: Option<CodeBlockTransformFn>,
290 },
291}
292
293pub type CodeBlockRenderFn = Arc<
294 dyn Fn(
295 &CodeBlockKind,
296 &ParsedMarkdown,
297 Range<usize>,
298 CodeBlockMetadata,
299 &mut Window,
300 &App,
301 ) -> Div,
302>;
303
304pub type CodeBlockTransformFn =
305 Arc<dyn Fn(AnyDiv, Range<usize>, CodeBlockMetadata, &mut Window, &App) -> AnyDiv>;
306
307actions!(
308 markdown,
309 [
310 /// Copies the selected text to the clipboard.
311 Copy,
312 /// Copies the selected text as markdown to the clipboard.
313 CopyAsMarkdown
314 ]
315);
316
317impl Markdown {
318 pub fn new(
319 source: SharedString,
320 language_registry: Option<Arc<LanguageRegistry>>,
321 fallback_code_block_language: Option<LanguageName>,
322 cx: &mut Context<Self>,
323 ) -> Self {
324 Self::new_with_options(
325 source,
326 language_registry,
327 fallback_code_block_language,
328 MarkdownOptions::default(),
329 cx,
330 )
331 }
332
333 pub fn new_with_options(
334 source: SharedString,
335 language_registry: Option<Arc<LanguageRegistry>>,
336 fallback_code_block_language: Option<LanguageName>,
337 options: MarkdownOptions,
338 cx: &mut Context<Self>,
339 ) -> Self {
340 let focus_handle = cx.focus_handle();
341 let mut this = Self {
342 source,
343 selection: Selection::default(),
344 pressed_link: None,
345 autoscroll_request: None,
346 active_root_block: None,
347 should_reparse: false,
348 images_by_source_offset: Default::default(),
349 parsed_markdown: ParsedMarkdown::default(),
350 pending_parse: None,
351 focus_handle,
352 language_registry,
353 fallback_code_block_language,
354 options,
355 mermaid_state: MermaidState::default(),
356 copied_code_blocks: HashSet::default(),
357 code_block_scroll_handles: BTreeMap::default(),
358 context_menu_selected_text: None,
359 };
360 this.parse(cx);
361 this
362 }
363
364 pub fn new_text(source: SharedString, cx: &mut Context<Self>) -> Self {
365 Self::new_with_options(
366 source,
367 None,
368 None,
369 MarkdownOptions {
370 parse_links_only: true,
371 ..Default::default()
372 },
373 cx,
374 )
375 }
376
377 fn code_block_scroll_handle(&mut self, id: usize) -> ScrollHandle {
378 self.code_block_scroll_handles
379 .entry(id)
380 .or_insert_with(ScrollHandle::new)
381 .clone()
382 }
383
384 fn retain_code_block_scroll_handles(&mut self, ids: &HashSet<usize>) {
385 self.code_block_scroll_handles
386 .retain(|id, _| ids.contains(id));
387 }
388
389 fn clear_code_block_scroll_handles(&mut self) {
390 self.code_block_scroll_handles.clear();
391 }
392
393 fn autoscroll_code_block(&self, source_index: usize, cursor_position: Point<Pixels>) {
394 let Some((_, scroll_handle)) = self
395 .code_block_scroll_handles
396 .range(..=source_index)
397 .next_back()
398 else {
399 return;
400 };
401
402 let bounds = scroll_handle.bounds();
403 if cursor_position.y < bounds.top() || cursor_position.y > bounds.bottom() {
404 return;
405 }
406
407 let horizontal_delta = if cursor_position.x < bounds.left() {
408 bounds.left() - cursor_position.x
409 } else if cursor_position.x > bounds.right() {
410 bounds.right() - cursor_position.x
411 } else {
412 return;
413 };
414
415 let offset = scroll_handle.offset();
416 scroll_handle.set_offset(point(offset.x + horizontal_delta, offset.y));
417 }
418
419 pub fn is_parsing(&self) -> bool {
420 self.pending_parse.is_some()
421 }
422
423 pub fn source(&self) -> &str {
424 &self.source
425 }
426
427 pub fn append(&mut self, text: &str, cx: &mut Context<Self>) {
428 self.source = SharedString::new(self.source.to_string() + text);
429 self.parse(cx);
430 }
431
432 pub fn replace(&mut self, source: impl Into<SharedString>, cx: &mut Context<Self>) {
433 self.source = source.into();
434 self.parse(cx);
435 }
436
437 pub fn request_autoscroll_to_source_index(
438 &mut self,
439 source_index: usize,
440 cx: &mut Context<Self>,
441 ) {
442 self.autoscroll_request = Some(source_index);
443 cx.refresh_windows();
444 }
445
446 pub fn set_active_root_for_source_index(
447 &mut self,
448 source_index: Option<usize>,
449 cx: &mut Context<Self>,
450 ) {
451 let active_root_block =
452 source_index.and_then(|index| self.parsed_markdown.root_block_for_source_index(index));
453 if self.active_root_block == active_root_block {
454 return;
455 }
456
457 self.active_root_block = active_root_block;
458 cx.notify();
459 }
460
461 pub fn reset(&mut self, source: SharedString, cx: &mut Context<Self>) {
462 if source == self.source() {
463 return;
464 }
465 self.source = source;
466 self.selection = Selection::default();
467 self.autoscroll_request = None;
468 self.pending_parse = None;
469 self.should_reparse = false;
470 // Don't clear parsed_markdown here - keep existing content visible until new parse completes
471 self.parse(cx);
472 }
473
474 #[cfg(any(test, feature = "test-support"))]
475 pub fn parsed_markdown(&self) -> &ParsedMarkdown {
476 &self.parsed_markdown
477 }
478
479 pub fn escape(s: &str) -> Cow<'_, str> {
480 // Valid to use bytes since multi-byte UTF-8 doesn't use ASCII chars.
481 let count = s
482 .bytes()
483 .filter(|c| *c == b'\n' || c.is_ascii_punctuation())
484 .count();
485 if count > 0 {
486 let mut output = String::with_capacity(s.len() + count);
487 let mut is_newline = false;
488 for c in s.chars() {
489 if is_newline && c == ' ' {
490 continue;
491 }
492 is_newline = c == '\n';
493 if c == '\n' {
494 output.push('\n')
495 } else if c.is_ascii_punctuation() {
496 output.push('\\')
497 }
498 output.push(c)
499 }
500 output.into()
501 } else {
502 s.into()
503 }
504 }
505
506 pub fn selected_text(&self) -> Option<String> {
507 if self.selection.end <= self.selection.start {
508 None
509 } else {
510 Some(self.source[self.selection.start..self.selection.end].to_string())
511 }
512 }
513
514 fn copy(&self, text: &RenderedText, _: &mut Window, cx: &mut Context<Self>) {
515 if self.selection.end <= self.selection.start {
516 return;
517 }
518 let text = text.text_for_range(self.selection.start..self.selection.end);
519 cx.write_to_clipboard(ClipboardItem::new_string(text));
520 }
521
522 fn copy_as_markdown(&mut self, _: &mut Window, cx: &mut Context<Self>) {
523 if let Some(text) = self.context_menu_selected_text.take() {
524 cx.write_to_clipboard(ClipboardItem::new_string(text));
525 return;
526 }
527 if self.selection.end <= self.selection.start {
528 return;
529 }
530 let text = self.source[self.selection.start..self.selection.end].to_string();
531 cx.write_to_clipboard(ClipboardItem::new_string(text));
532 }
533
534 fn capture_selection_for_context_menu(&mut self) {
535 self.context_menu_selected_text = self.selected_text();
536 }
537
538 fn parse(&mut self, cx: &mut Context<Self>) {
539 if self.source.is_empty() {
540 self.should_reparse = false;
541 self.pending_parse.take();
542 self.parsed_markdown = ParsedMarkdown {
543 source: self.source.clone(),
544 ..Default::default()
545 };
546 self.active_root_block = None;
547 self.images_by_source_offset.clear();
548 self.mermaid_state.clear();
549 cx.notify();
550 cx.refresh_windows();
551 return;
552 }
553
554 if self.pending_parse.is_some() {
555 self.should_reparse = true;
556 return;
557 }
558 self.should_reparse = false;
559 self.pending_parse = Some(self.start_background_parse(cx));
560 }
561
562 fn start_background_parse(&self, cx: &Context<Self>) -> Task<()> {
563 let source = self.source.clone();
564 let should_parse_links_only = self.options.parse_links_only;
565 let should_parse_html = self.options.parse_html;
566 let should_render_mermaid_diagrams = self.options.render_mermaid_diagrams;
567 let language_registry = self.language_registry.clone();
568 let fallback = self.fallback_code_block_language.clone();
569
570 let parsed = cx.background_spawn(async move {
571 if should_parse_links_only {
572 return (
573 ParsedMarkdown {
574 events: Arc::from(parse_links_only(source.as_ref())),
575 source,
576 languages_by_name: TreeMap::default(),
577 languages_by_path: TreeMap::default(),
578 root_block_starts: Arc::default(),
579 html_blocks: BTreeMap::default(),
580 mermaid_diagrams: BTreeMap::default(),
581 },
582 Default::default(),
583 );
584 }
585
586 let parsed = parse_markdown_with_options(&source, should_parse_html);
587 let events = parsed.events;
588 let language_names = parsed.language_names;
589 let paths = parsed.language_paths;
590 let root_block_starts = parsed.root_block_starts;
591 let html_blocks = parsed.html_blocks;
592 let mermaid_diagrams = if should_render_mermaid_diagrams {
593 extract_mermaid_diagrams(&source, &events)
594 } else {
595 BTreeMap::default()
596 };
597 let mut images_by_source_offset = HashMap::default();
598 let mut languages_by_name = TreeMap::default();
599 let mut languages_by_path = TreeMap::default();
600 if let Some(registry) = language_registry.as_ref() {
601 for name in language_names {
602 let language = if !name.is_empty() {
603 registry.language_for_name_or_extension(&name).left_future()
604 } else if let Some(fallback) = &fallback {
605 registry.language_for_name(fallback.as_ref()).right_future()
606 } else {
607 continue;
608 };
609 if let Ok(language) = language.await {
610 languages_by_name.insert(name, language);
611 }
612 }
613
614 for path in paths {
615 if let Ok(language) = registry
616 .load_language_for_file_path(Path::new(path.as_ref()))
617 .await
618 {
619 languages_by_path.insert(path, language);
620 }
621 }
622 }
623
624 for (range, event) in &events {
625 if let MarkdownEvent::Start(MarkdownTag::Image { dest_url, .. }) = event
626 && let Some(data_url) = dest_url.strip_prefix("data:")
627 {
628 let Some((mime_info, data)) = data_url.split_once(',') else {
629 continue;
630 };
631 let Some((mime_type, encoding)) = mime_info.split_once(';') else {
632 continue;
633 };
634 let Some(format) = ImageFormat::from_mime_type(mime_type) else {
635 continue;
636 };
637 let is_base64 = encoding == "base64";
638 if is_base64
639 && let Some(bytes) = base64::prelude::BASE64_STANDARD
640 .decode(data)
641 .log_with_level(Level::Debug)
642 {
643 let image = Arc::new(Image::from_bytes(format, bytes));
644 images_by_source_offset.insert(range.start, image);
645 }
646 }
647 }
648
649 (
650 ParsedMarkdown {
651 source,
652 events: Arc::from(events),
653 languages_by_name,
654 languages_by_path,
655 root_block_starts: Arc::from(root_block_starts),
656 html_blocks,
657 mermaid_diagrams,
658 },
659 images_by_source_offset,
660 )
661 });
662
663 cx.spawn(async move |this, cx| {
664 let (parsed, images_by_source_offset) = parsed.await;
665
666 this.update(cx, |this, cx| {
667 this.parsed_markdown = parsed;
668 this.images_by_source_offset = images_by_source_offset;
669 if this.active_root_block.is_some_and(|block_index| {
670 block_index >= this.parsed_markdown.root_block_starts.len()
671 }) {
672 this.active_root_block = None;
673 }
674 if this.options.render_mermaid_diagrams {
675 let parsed_markdown = this.parsed_markdown.clone();
676 this.mermaid_state.update(&parsed_markdown, cx);
677 } else {
678 this.mermaid_state.clear();
679 }
680 this.pending_parse.take();
681 if this.should_reparse {
682 this.parse(cx);
683 }
684 cx.notify();
685 cx.refresh_windows();
686 })
687 .ok();
688 })
689 }
690}
691
692impl Focusable for Markdown {
693 fn focus_handle(&self, _cx: &App) -> FocusHandle {
694 self.focus_handle.clone()
695 }
696}
697
698#[derive(Debug, Default, Clone)]
699enum SelectMode {
700 #[default]
701 Character,
702 Word(Range<usize>),
703 Line(Range<usize>),
704 All,
705}
706
707#[derive(Clone, Default)]
708struct Selection {
709 start: usize,
710 end: usize,
711 reversed: bool,
712 pending: bool,
713 mode: SelectMode,
714}
715
716impl Selection {
717 fn set_head(&mut self, head: usize, rendered_text: &RenderedText) {
718 match &self.mode {
719 SelectMode::Character => {
720 if head < self.tail() {
721 if !self.reversed {
722 self.end = self.start;
723 self.reversed = true;
724 }
725 self.start = head;
726 } else {
727 if self.reversed {
728 self.start = self.end;
729 self.reversed = false;
730 }
731 self.end = head;
732 }
733 }
734 SelectMode::Word(original_range) | SelectMode::Line(original_range) => {
735 let head_range = if matches!(self.mode, SelectMode::Word(_)) {
736 rendered_text.surrounding_word_range(head)
737 } else {
738 rendered_text.surrounding_line_range(head)
739 };
740
741 if head < original_range.start {
742 self.start = head_range.start;
743 self.end = original_range.end;
744 self.reversed = true;
745 } else if head >= original_range.end {
746 self.start = original_range.start;
747 self.end = head_range.end;
748 self.reversed = false;
749 } else {
750 self.start = original_range.start;
751 self.end = original_range.end;
752 self.reversed = false;
753 }
754 }
755 SelectMode::All => {
756 self.start = 0;
757 self.end = rendered_text
758 .lines
759 .last()
760 .map(|line| line.source_end)
761 .unwrap_or(0);
762 self.reversed = false;
763 }
764 }
765 }
766
767 fn tail(&self) -> usize {
768 if self.reversed { self.end } else { self.start }
769 }
770}
771
772#[derive(Debug, Clone, Default)]
773pub struct ParsedMarkdown {
774 pub source: SharedString,
775 pub events: Arc<[(Range<usize>, MarkdownEvent)]>,
776 pub languages_by_name: TreeMap<SharedString, Arc<Language>>,
777 pub languages_by_path: TreeMap<Arc<str>, Arc<Language>>,
778 pub root_block_starts: Arc<[usize]>,
779 pub(crate) html_blocks: BTreeMap<usize, html::html_parser::ParsedHtmlBlock>,
780 pub(crate) mermaid_diagrams: BTreeMap<usize, ParsedMarkdownMermaidDiagram>,
781}
782
783impl ParsedMarkdown {
784 pub fn source(&self) -> &SharedString {
785 &self.source
786 }
787
788 pub fn events(&self) -> &Arc<[(Range<usize>, MarkdownEvent)]> {
789 &self.events
790 }
791
792 pub fn root_block_starts(&self) -> &Arc<[usize]> {
793 &self.root_block_starts
794 }
795
796 pub fn root_block_for_source_index(&self, source_index: usize) -> Option<usize> {
797 if self.root_block_starts.is_empty() {
798 return None;
799 }
800
801 let partition = self
802 .root_block_starts
803 .partition_point(|block_start| *block_start <= source_index);
804
805 Some(partition.saturating_sub(1))
806 }
807}
808
809pub enum AutoscrollBehavior {
810 /// Propagate the request up the element tree for the nearest
811 /// scrollable ancestor (e.g. `List`) to handle.
812 Propagate,
813 /// Directly control a specific scroll handle.
814 Controlled(ScrollHandle),
815}
816
817pub struct MarkdownElement {
818 markdown: Entity<Markdown>,
819 style: MarkdownStyle,
820 code_block_renderer: CodeBlockRenderer,
821 on_url_click: Option<Box<dyn Fn(SharedString, &mut Window, &mut App)>>,
822 on_source_click: Option<SourceClickCallback>,
823 on_checkbox_toggle: Option<CheckboxToggleCallback>,
824 image_resolver: Option<Box<dyn Fn(&str) -> Option<ImageSource>>>,
825 show_root_block_markers: bool,
826 autoscroll: AutoscrollBehavior,
827}
828
829impl MarkdownElement {
830 pub fn new(markdown: Entity<Markdown>, style: MarkdownStyle) -> Self {
831 Self {
832 markdown,
833 style,
834 code_block_renderer: CodeBlockRenderer::Default {
835 copy_button_visibility: CopyButtonVisibility::VisibleOnHover,
836 border: false,
837 },
838 on_url_click: None,
839 on_source_click: None,
840 on_checkbox_toggle: None,
841 image_resolver: None,
842 show_root_block_markers: false,
843 autoscroll: AutoscrollBehavior::Propagate,
844 }
845 }
846
847 #[cfg(any(test, feature = "test-support"))]
848 pub fn rendered_text(
849 markdown: Entity<Markdown>,
850 cx: &mut gpui::VisualTestContext,
851 style: impl FnOnce(&Window, &App) -> MarkdownStyle,
852 ) -> String {
853 use gpui::size;
854
855 let (text, _) = cx.draw(
856 Default::default(),
857 size(px(600.0), px(600.0)),
858 |window, cx| Self::new(markdown, style(window, cx)),
859 );
860 text.text
861 .lines
862 .iter()
863 .map(|line| line.layout.wrapped_text())
864 .collect::<Vec<_>>()
865 .join("\n")
866 }
867
868 pub fn code_block_renderer(mut self, variant: CodeBlockRenderer) -> Self {
869 self.code_block_renderer = variant;
870 self
871 }
872
873 pub fn on_url_click(
874 mut self,
875 handler: impl Fn(SharedString, &mut Window, &mut App) + 'static,
876 ) -> Self {
877 self.on_url_click = Some(Box::new(handler));
878 self
879 }
880
881 pub fn on_source_click(
882 mut self,
883 handler: impl Fn(usize, usize, &mut Window, &mut App) -> bool + 'static,
884 ) -> Self {
885 self.on_source_click = Some(Box::new(handler));
886 self
887 }
888
889 pub fn on_checkbox_toggle(
890 mut self,
891 handler: impl Fn(Range<usize>, bool, &mut Window, &mut App) + 'static,
892 ) -> Self {
893 self.on_checkbox_toggle = Some(Rc::new(handler));
894 self
895 }
896
897 pub fn image_resolver(
898 mut self,
899 resolver: impl Fn(&str) -> Option<ImageSource> + 'static,
900 ) -> Self {
901 self.image_resolver = Some(Box::new(resolver));
902 self
903 }
904
905 pub fn show_root_block_markers(mut self) -> Self {
906 self.show_root_block_markers = true;
907 self
908 }
909
910 pub fn scroll_handle(mut self, scroll_handle: ScrollHandle) -> Self {
911 self.autoscroll = AutoscrollBehavior::Controlled(scroll_handle);
912 self
913 }
914
915 fn push_markdown_image(
916 &self,
917 builder: &mut MarkdownElementBuilder,
918 range: &Range<usize>,
919 source: ImageSource,
920 width: Option<DefiniteLength>,
921 height: Option<DefiniteLength>,
922 ) {
923 builder.modify_current_div(|el| {
924 el.items_center().flex().flex_row().child(
925 img(source)
926 .max_w_full()
927 .when_some(height, |this, height| this.h(height))
928 .when_some(width, |this, width| this.w(width)),
929 )
930 });
931 let _ = range;
932 }
933
934 fn push_markdown_paragraph(
935 &self,
936 builder: &mut MarkdownElementBuilder,
937 range: &Range<usize>,
938 markdown_end: usize,
939 ) {
940 builder.push_div(
941 div().when(!self.style.height_is_multiple_of_line_height, |el| {
942 el.mb_2().line_height(rems(1.3))
943 }),
944 range,
945 markdown_end,
946 );
947 }
948
949 fn push_markdown_heading(
950 &self,
951 builder: &mut MarkdownElementBuilder,
952 level: pulldown_cmark::HeadingLevel,
953 range: &Range<usize>,
954 markdown_end: usize,
955 ) {
956 let mut heading = div().mb_2();
957 heading = apply_heading_style(heading, level, self.style.heading_level_styles.as_ref());
958
959 let mut heading_style = self.style.heading.clone();
960 let heading_text_style = heading_style.text_style().clone();
961 heading.style().refine(&heading_style);
962
963 builder.push_text_style(heading_text_style);
964 builder.push_div(heading, range, markdown_end);
965 }
966
967 fn pop_markdown_heading(&self, builder: &mut MarkdownElementBuilder) {
968 builder.pop_div();
969 builder.pop_text_style();
970 }
971
972 fn push_markdown_block_quote(
973 &self,
974 builder: &mut MarkdownElementBuilder,
975 range: &Range<usize>,
976 markdown_end: usize,
977 ) {
978 builder.push_text_style(self.style.block_quote.clone());
979 builder.push_div(
980 div()
981 .pl_4()
982 .mb_2()
983 .border_l_4()
984 .border_color(self.style.block_quote_border_color),
985 range,
986 markdown_end,
987 );
988 }
989
990 fn pop_markdown_block_quote(&self, builder: &mut MarkdownElementBuilder) {
991 builder.pop_div();
992 builder.pop_text_style();
993 }
994
995 fn push_markdown_list_item(
996 &self,
997 builder: &mut MarkdownElementBuilder,
998 bullet: AnyElement,
999 range: &Range<usize>,
1000 markdown_end: usize,
1001 ) {
1002 builder.push_div(
1003 div()
1004 .when(!self.style.height_is_multiple_of_line_height, |el| {
1005 el.mb_1().gap_1().line_height(rems(1.3))
1006 })
1007 .h_flex()
1008 .items_start()
1009 .child(bullet),
1010 range,
1011 markdown_end,
1012 );
1013 // Without `w_0`, text doesn't wrap to the width of the container.
1014 builder.push_div(div().flex_1().w_0(), range, markdown_end);
1015 }
1016
1017 fn pop_markdown_list_item(&self, builder: &mut MarkdownElementBuilder) {
1018 builder.pop_div();
1019 builder.pop_div();
1020 }
1021
1022 fn paint_selection(
1023 &self,
1024 bounds: Bounds<Pixels>,
1025 rendered_text: &RenderedText,
1026 window: &mut Window,
1027 cx: &mut App,
1028 ) {
1029 let selection = self.markdown.read(cx).selection.clone();
1030 let selection_start = rendered_text.position_for_source_index(selection.start);
1031 let selection_end = rendered_text.position_for_source_index(selection.end);
1032 if let Some(((start_position, start_line_height), (end_position, end_line_height))) =
1033 selection_start.zip(selection_end)
1034 {
1035 if start_position.y == end_position.y {
1036 window.paint_quad(quad(
1037 Bounds::from_corners(
1038 start_position,
1039 point(end_position.x, end_position.y + end_line_height),
1040 ),
1041 Pixels::ZERO,
1042 self.style.selection_background_color,
1043 Edges::default(),
1044 Hsla::transparent_black(),
1045 BorderStyle::default(),
1046 ));
1047 } else {
1048 window.paint_quad(quad(
1049 Bounds::from_corners(
1050 start_position,
1051 point(bounds.right(), start_position.y + start_line_height),
1052 ),
1053 Pixels::ZERO,
1054 self.style.selection_background_color,
1055 Edges::default(),
1056 Hsla::transparent_black(),
1057 BorderStyle::default(),
1058 ));
1059
1060 if end_position.y > start_position.y + start_line_height {
1061 window.paint_quad(quad(
1062 Bounds::from_corners(
1063 point(bounds.left(), start_position.y + start_line_height),
1064 point(bounds.right(), end_position.y),
1065 ),
1066 Pixels::ZERO,
1067 self.style.selection_background_color,
1068 Edges::default(),
1069 Hsla::transparent_black(),
1070 BorderStyle::default(),
1071 ));
1072 }
1073
1074 window.paint_quad(quad(
1075 Bounds::from_corners(
1076 point(bounds.left(), end_position.y),
1077 point(end_position.x, end_position.y + end_line_height),
1078 ),
1079 Pixels::ZERO,
1080 self.style.selection_background_color,
1081 Edges::default(),
1082 Hsla::transparent_black(),
1083 BorderStyle::default(),
1084 ));
1085 }
1086 }
1087 }
1088
1089 fn paint_mouse_listeners(
1090 &mut self,
1091 hitbox: &Hitbox,
1092 rendered_text: &RenderedText,
1093 window: &mut Window,
1094 cx: &mut App,
1095 ) {
1096 if self.style.prevent_mouse_interaction {
1097 return;
1098 }
1099
1100 let is_hovering_link = hitbox.is_hovered(window)
1101 && !self.markdown.read(cx).selection.pending
1102 && rendered_text
1103 .link_for_position(window.mouse_position())
1104 .is_some();
1105
1106 if !self.style.prevent_mouse_interaction {
1107 if is_hovering_link {
1108 window.set_cursor_style(CursorStyle::PointingHand, hitbox);
1109 } else {
1110 window.set_cursor_style(CursorStyle::IBeam, hitbox);
1111 }
1112 }
1113
1114 let on_open_url = self.on_url_click.take();
1115 let on_source_click = self.on_source_click.take();
1116
1117 self.on_mouse_event(window, cx, {
1118 let hitbox = hitbox.clone();
1119 move |markdown, event: &MouseDownEvent, phase, window, _| {
1120 if phase.capture()
1121 && event.button == MouseButton::Right
1122 && hitbox.is_hovered(window)
1123 {
1124 // Capture selected text so it survives until menu item is clicked
1125 markdown.capture_selection_for_context_menu();
1126 }
1127 }
1128 });
1129
1130 self.on_mouse_event(window, cx, {
1131 let rendered_text = rendered_text.clone();
1132 let hitbox = hitbox.clone();
1133 move |markdown, event: &MouseDownEvent, phase, window, cx| {
1134 if hitbox.is_hovered(window) {
1135 if phase.bubble() {
1136 if let Some(link) = rendered_text.link_for_position(event.position) {
1137 markdown.pressed_link = Some(link.clone());
1138 } else {
1139 let source_index =
1140 match rendered_text.source_index_for_position(event.position) {
1141 Ok(ix) | Err(ix) => ix,
1142 };
1143 if let Some(handler) = on_source_click.as_ref() {
1144 let blocked = handler(source_index, event.click_count, window, cx);
1145 if blocked {
1146 markdown.selection = Selection::default();
1147 markdown.pressed_link = None;
1148 window.prevent_default();
1149 cx.notify();
1150 return;
1151 }
1152 }
1153 let (range, mode) = match event.click_count {
1154 1 => {
1155 let range = source_index..source_index;
1156 (range, SelectMode::Character)
1157 }
1158 2 => {
1159 let range = rendered_text.surrounding_word_range(source_index);
1160 (range.clone(), SelectMode::Word(range))
1161 }
1162 3 => {
1163 let range = rendered_text.surrounding_line_range(source_index);
1164 (range.clone(), SelectMode::Line(range))
1165 }
1166 _ => {
1167 let range = 0..rendered_text
1168 .lines
1169 .last()
1170 .map(|line| line.source_end)
1171 .unwrap_or(0);
1172 (range, SelectMode::All)
1173 }
1174 };
1175 markdown.selection = Selection {
1176 start: range.start,
1177 end: range.end,
1178 reversed: false,
1179 pending: true,
1180 mode,
1181 };
1182 window.focus(&markdown.focus_handle, cx);
1183 }
1184
1185 window.prevent_default();
1186 cx.notify();
1187 }
1188 } else if phase.capture() && event.button == MouseButton::Left {
1189 markdown.selection = Selection::default();
1190 markdown.pressed_link = None;
1191 cx.notify();
1192 }
1193 }
1194 });
1195 self.on_mouse_event(window, cx, {
1196 let rendered_text = rendered_text.clone();
1197 let hitbox = hitbox.clone();
1198 let was_hovering_link = is_hovering_link;
1199 move |markdown, event: &MouseMoveEvent, phase, window, cx| {
1200 if phase.capture() {
1201 return;
1202 }
1203
1204 if markdown.selection.pending {
1205 let source_index = match rendered_text.source_index_for_position(event.position)
1206 {
1207 Ok(ix) | Err(ix) => ix,
1208 };
1209 markdown.selection.set_head(source_index, &rendered_text);
1210 markdown.autoscroll_code_block(source_index, event.position);
1211 markdown.autoscroll_request = Some(source_index);
1212 cx.notify();
1213 } else {
1214 let is_hovering_link = hitbox.is_hovered(window)
1215 && rendered_text.link_for_position(event.position).is_some();
1216 if is_hovering_link != was_hovering_link {
1217 cx.notify();
1218 }
1219 }
1220 }
1221 });
1222 self.on_mouse_event(window, cx, {
1223 let rendered_text = rendered_text.clone();
1224 move |markdown, event: &MouseUpEvent, phase, window, cx| {
1225 if phase.bubble() {
1226 if let Some(pressed_link) = markdown.pressed_link.take()
1227 && Some(&pressed_link) == rendered_text.link_for_position(event.position)
1228 {
1229 if let Some(open_url) = on_open_url.as_ref() {
1230 open_url(pressed_link.destination_url, window, cx);
1231 } else {
1232 cx.open_url(&pressed_link.destination_url);
1233 }
1234 }
1235 } else if markdown.selection.pending {
1236 markdown.selection.pending = false;
1237 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
1238 {
1239 let text = rendered_text
1240 .text_for_range(markdown.selection.start..markdown.selection.end);
1241 cx.write_to_primary(ClipboardItem::new_string(text))
1242 }
1243 cx.notify();
1244 }
1245 }
1246 });
1247 }
1248
1249 fn autoscroll(
1250 &self,
1251 rendered_text: &RenderedText,
1252 window: &mut Window,
1253 cx: &mut App,
1254 ) -> Option<()> {
1255 let autoscroll_index = self
1256 .markdown
1257 .update(cx, |markdown, _| markdown.autoscroll_request.take())?;
1258 let (position, line_height) = rendered_text.position_for_source_index(autoscroll_index)?;
1259
1260 match &self.autoscroll {
1261 AutoscrollBehavior::Controlled(scroll_handle) => {
1262 let viewport = scroll_handle.bounds();
1263 let margin = line_height * 3.;
1264 let top_goal = viewport.top() + margin;
1265 let bottom_goal = viewport.bottom() - margin;
1266 let current_offset = scroll_handle.offset();
1267
1268 let new_offset_y = if position.y < top_goal {
1269 current_offset.y + (top_goal - position.y)
1270 } else if position.y + line_height > bottom_goal {
1271 current_offset.y + (bottom_goal - (position.y + line_height))
1272 } else {
1273 current_offset.y
1274 };
1275
1276 scroll_handle.set_offset(point(
1277 current_offset.x,
1278 new_offset_y.clamp(-scroll_handle.max_offset().y, Pixels::ZERO),
1279 ));
1280 }
1281 AutoscrollBehavior::Propagate => {
1282 let text_style = self.style.base_text_style.clone();
1283 let font_id = window.text_system().resolve_font(&text_style.font());
1284 let font_size = text_style.font_size.to_pixels(window.rem_size());
1285 let em_width = window.text_system().em_width(font_id, font_size).unwrap();
1286 window.request_autoscroll(Bounds::from_corners(
1287 point(position.x - 3. * em_width, position.y - 3. * line_height),
1288 point(position.x + 3. * em_width, position.y + 3. * line_height),
1289 ));
1290 }
1291 }
1292 Some(())
1293 }
1294
1295 fn on_mouse_event<T: MouseEvent>(
1296 &self,
1297 window: &mut Window,
1298 _cx: &mut App,
1299 mut f: impl 'static
1300 + FnMut(&mut Markdown, &T, DispatchPhase, &mut Window, &mut Context<Markdown>),
1301 ) {
1302 window.on_mouse_event({
1303 let markdown = self.markdown.downgrade();
1304 move |event, phase, window, cx| {
1305 markdown
1306 .update(cx, |markdown, cx| f(markdown, event, phase, window, cx))
1307 .log_err();
1308 }
1309 });
1310 }
1311}
1312
1313impl Styled for MarkdownElement {
1314 fn style(&mut self) -> &mut StyleRefinement {
1315 &mut self.style.container_style
1316 }
1317}
1318
1319impl Element for MarkdownElement {
1320 type RequestLayoutState = RenderedMarkdown;
1321 type PrepaintState = Hitbox;
1322
1323 fn id(&self) -> Option<ElementId> {
1324 None
1325 }
1326
1327 fn source_location(&self) -> Option<&'static core::panic::Location<'static>> {
1328 None
1329 }
1330
1331 fn request_layout(
1332 &mut self,
1333 _id: Option<&GlobalElementId>,
1334 _inspector_id: Option<&gpui::InspectorElementId>,
1335 window: &mut Window,
1336 cx: &mut App,
1337 ) -> (gpui::LayoutId, Self::RequestLayoutState) {
1338 let mut builder = MarkdownElementBuilder::new(
1339 &self.style.container_style,
1340 self.style.base_text_style.clone(),
1341 self.style.syntax.clone(),
1342 );
1343 let (parsed_markdown, images, active_root_block, render_mermaid_diagrams, mermaid_state) = {
1344 let markdown = self.markdown.read(cx);
1345 (
1346 markdown.parsed_markdown.clone(),
1347 markdown.images_by_source_offset.clone(),
1348 markdown.active_root_block,
1349 markdown.options.render_mermaid_diagrams,
1350 markdown.mermaid_state.clone(),
1351 )
1352 };
1353 let markdown_end = if let Some(last) = parsed_markdown.events.last() {
1354 last.0.end
1355 } else {
1356 0
1357 };
1358 let mut code_block_ids = HashSet::default();
1359
1360 let mut current_img_block_range: Option<Range<usize>> = None;
1361 let mut handled_html_block = false;
1362 let mut rendered_mermaid_block = false;
1363 for (index, (range, event)) in parsed_markdown.events.iter().enumerate() {
1364 // Skip alt text for images that rendered
1365 if let Some(current_img_block_range) = ¤t_img_block_range
1366 && current_img_block_range.end > range.end
1367 {
1368 continue;
1369 }
1370
1371 if handled_html_block {
1372 if let MarkdownEvent::End(MarkdownTagEnd::HtmlBlock) = event {
1373 handled_html_block = false;
1374 } else {
1375 continue;
1376 }
1377 }
1378
1379 if rendered_mermaid_block {
1380 if matches!(event, MarkdownEvent::End(MarkdownTagEnd::CodeBlock)) {
1381 rendered_mermaid_block = false;
1382 }
1383 continue;
1384 }
1385
1386 match event {
1387 MarkdownEvent::RootStart => {
1388 if self.show_root_block_markers {
1389 builder.push_root_block(range, markdown_end);
1390 }
1391 }
1392 MarkdownEvent::RootEnd(root_block_index) => {
1393 if self.show_root_block_markers {
1394 builder.pop_root_block(
1395 active_root_block == Some(*root_block_index),
1396 cx.theme().colors().border,
1397 cx.theme().colors().border_variant,
1398 );
1399 }
1400 }
1401 MarkdownEvent::Start(tag) => {
1402 match tag {
1403 MarkdownTag::Image { dest_url, .. } => {
1404 if let Some(image) = images.get(&range.start) {
1405 current_img_block_range = Some(range.clone());
1406 self.push_markdown_image(
1407 &mut builder,
1408 range,
1409 image.clone().into(),
1410 None,
1411 None,
1412 );
1413 } else if let Some(source) = self
1414 .image_resolver
1415 .as_ref()
1416 .and_then(|resolve| resolve(dest_url.as_ref()))
1417 {
1418 current_img_block_range = Some(range.clone());
1419 self.push_markdown_image(&mut builder, range, source, None, None);
1420 }
1421 }
1422 MarkdownTag::Paragraph => {
1423 self.push_markdown_paragraph(&mut builder, range, markdown_end);
1424 }
1425 MarkdownTag::Heading { level, .. } => {
1426 self.push_markdown_heading(&mut builder, *level, range, markdown_end);
1427 }
1428 MarkdownTag::BlockQuote => {
1429 self.push_markdown_block_quote(&mut builder, range, markdown_end);
1430 }
1431 MarkdownTag::CodeBlock { kind, .. } => {
1432 if render_mermaid_diagrams
1433 && let Some(mermaid_diagram) =
1434 parsed_markdown.mermaid_diagrams.get(&range.start)
1435 {
1436 builder.push_sourced_element(
1437 mermaid_diagram.content_range.clone(),
1438 render_mermaid_diagram(
1439 mermaid_diagram,
1440 &mermaid_state,
1441 &self.style,
1442 ),
1443 );
1444 rendered_mermaid_block = true;
1445 continue;
1446 }
1447
1448 let language = match kind {
1449 CodeBlockKind::Fenced => None,
1450 CodeBlockKind::FencedLang(language) => {
1451 parsed_markdown.languages_by_name.get(language).cloned()
1452 }
1453 CodeBlockKind::FencedSrc(path_range) => parsed_markdown
1454 .languages_by_path
1455 .get(&path_range.path)
1456 .cloned(),
1457 _ => None,
1458 };
1459
1460 let is_indented = matches!(kind, CodeBlockKind::Indented);
1461 let scroll_handle = if self.style.code_block_overflow_x_scroll {
1462 code_block_ids.insert(range.start);
1463 Some(self.markdown.update(cx, |markdown, _| {
1464 markdown.code_block_scroll_handle(range.start)
1465 }))
1466 } else {
1467 None
1468 };
1469
1470 match (&self.code_block_renderer, is_indented) {
1471 (CodeBlockRenderer::Default { .. }, _) | (_, true) => {
1472 // This is a parent container that we can position the copy button inside.
1473 let parent_container =
1474 div().group("code_block").relative().w_full();
1475
1476 let mut parent_container: AnyDiv = if let Some(scroll_handle) =
1477 scroll_handle.as_ref()
1478 {
1479 let scrollbars = Scrollbars::new(ScrollAxes::Horizontal)
1480 .id(("markdown-code-block-scrollbar", range.start))
1481 .tracked_scroll_handle(scroll_handle)
1482 .with_track_along(
1483 ScrollAxes::Horizontal,
1484 cx.theme().colors().editor_background,
1485 )
1486 .notify_content();
1487
1488 parent_container
1489 .rounded_lg()
1490 .custom_scrollbars(scrollbars, window, cx)
1491 .into()
1492 } else {
1493 parent_container.into()
1494 };
1495
1496 if let CodeBlockRenderer::Default { border: true, .. } =
1497 &self.code_block_renderer
1498 {
1499 parent_container = parent_container
1500 .rounded_md()
1501 .border_1()
1502 .border_color(cx.theme().colors().border_variant);
1503 }
1504
1505 parent_container.style().refine(&self.style.code_block);
1506 builder.push_div(parent_container, range, markdown_end);
1507
1508 let code_block = div()
1509 .id(("code-block", range.start))
1510 .rounded_lg()
1511 .map(|mut code_block| {
1512 if let Some(scroll_handle) = scroll_handle.as_ref() {
1513 code_block.style().restrict_scroll_to_axis =
1514 Some(true);
1515 code_block
1516 .flex()
1517 .overflow_x_scroll()
1518 .track_scroll(scroll_handle)
1519 } else {
1520 code_block.w_full()
1521 }
1522 });
1523
1524 builder.push_text_style(self.style.code_block.text.to_owned());
1525 builder.push_code_block(language);
1526 builder.push_div(code_block, range, markdown_end);
1527 }
1528 (CodeBlockRenderer::Custom { .. }, _) => {}
1529 }
1530 }
1531 MarkdownTag::HtmlBlock => {
1532 builder.push_div(div(), range, markdown_end);
1533 if let Some(block) = parsed_markdown.html_blocks.get(&range.start) {
1534 self.render_html_block(block, &mut builder, markdown_end, cx);
1535 handled_html_block = true;
1536 }
1537 }
1538 MarkdownTag::List(bullet_index) => {
1539 builder.push_list(*bullet_index);
1540 builder.push_div(div().pl_2p5(), range, markdown_end);
1541 }
1542 MarkdownTag::Item => {
1543 let bullet =
1544 if let Some((task_range, MarkdownEvent::TaskListMarker(checked))) =
1545 parsed_markdown.events.get(index.saturating_add(1))
1546 {
1547 let source = &parsed_markdown.source()[range.clone()];
1548 let checked = *checked;
1549 let toggle_state = if checked {
1550 ToggleState::Selected
1551 } else {
1552 ToggleState::Unselected
1553 };
1554
1555 let checkbox = Checkbox::new(
1556 ElementId::Name(source.to_string().into()),
1557 toggle_state,
1558 )
1559 .fill();
1560
1561 if let Some(on_toggle) = self.on_checkbox_toggle.clone() {
1562 let task_source_range = task_range.clone();
1563 checkbox
1564 .on_click(move |_state, window, cx| {
1565 on_toggle(
1566 task_source_range.clone(),
1567 !checked,
1568 window,
1569 cx,
1570 );
1571 })
1572 .into_any_element()
1573 } else {
1574 checkbox.visualization_only(true).into_any_element()
1575 }
1576 } else if let Some(bullet_index) = builder.next_bullet_index() {
1577 div().child(format!("{}.", bullet_index)).into_any_element()
1578 } else {
1579 div().child("•").into_any_element()
1580 };
1581 self.push_markdown_list_item(&mut builder, bullet, range, markdown_end);
1582 }
1583 MarkdownTag::Emphasis => builder.push_text_style(TextStyleRefinement {
1584 font_style: Some(FontStyle::Italic),
1585 ..Default::default()
1586 }),
1587 MarkdownTag::Strong => builder.push_text_style(TextStyleRefinement {
1588 font_weight: Some(FontWeight::BOLD),
1589 ..Default::default()
1590 }),
1591 MarkdownTag::Strikethrough => {
1592 builder.push_text_style(TextStyleRefinement {
1593 strikethrough: Some(StrikethroughStyle {
1594 thickness: px(1.),
1595 color: None,
1596 }),
1597 ..Default::default()
1598 })
1599 }
1600 MarkdownTag::Link { dest_url, .. } => {
1601 if builder.code_block_stack.is_empty() {
1602 builder.push_link(dest_url.clone(), range.clone());
1603 let style = self
1604 .style
1605 .link_callback
1606 .as_ref()
1607 .and_then(|callback| callback(dest_url, cx))
1608 .unwrap_or_else(|| self.style.link.clone());
1609 builder.push_text_style(style)
1610 }
1611 }
1612 MarkdownTag::MetadataBlock(_) => {}
1613 MarkdownTag::Table(alignments) => {
1614 builder.table.start(alignments.clone());
1615
1616 let column_count = alignments.len();
1617 builder.push_div(
1618 div()
1619 .id(("table", range.start))
1620 .grid()
1621 .grid_cols(column_count as u16)
1622 .when(self.style.table_columns_min_size, |this| {
1623 this.grid_cols_min_content(column_count as u16)
1624 })
1625 .when(!self.style.table_columns_min_size, |this| {
1626 this.grid_cols(column_count as u16)
1627 })
1628 .w_full()
1629 .mb_2()
1630 .border(px(1.5))
1631 .border_color(cx.theme().colors().border)
1632 .rounded_sm()
1633 .overflow_hidden(),
1634 range,
1635 markdown_end,
1636 );
1637 }
1638 MarkdownTag::TableHead => {
1639 builder.table.start_head();
1640 builder.push_text_style(TextStyleRefinement {
1641 font_weight: Some(FontWeight::SEMIBOLD),
1642 ..Default::default()
1643 });
1644 }
1645 MarkdownTag::TableRow => {
1646 builder.table.start_row();
1647 }
1648 MarkdownTag::TableCell => {
1649 let is_header = builder.table.in_head;
1650 let row_index = builder.table.row_index;
1651 let col_index = builder.table.col_index;
1652
1653 builder.push_div(
1654 div()
1655 .when(col_index > 0, |this| this.border_l_1())
1656 .when(row_index > 0, |this| this.border_t_1())
1657 .border_color(cx.theme().colors().border)
1658 .px_1()
1659 .py_0p5()
1660 .when(is_header, |this| {
1661 this.bg(cx.theme().colors().title_bar_background)
1662 })
1663 .when(!is_header && row_index % 2 == 1, |this| {
1664 this.bg(cx.theme().colors().panel_background)
1665 }),
1666 range,
1667 markdown_end,
1668 );
1669 }
1670 _ => log::debug!("unsupported markdown tag {:?}", tag),
1671 }
1672 }
1673 MarkdownEvent::End(tag) => match tag {
1674 MarkdownTagEnd::Image => {
1675 current_img_block_range.take();
1676 }
1677 MarkdownTagEnd::Paragraph => {
1678 builder.pop_div();
1679 }
1680 MarkdownTagEnd::Heading(_) => {
1681 self.pop_markdown_heading(&mut builder);
1682 }
1683 MarkdownTagEnd::BlockQuote(_kind) => {
1684 self.pop_markdown_block_quote(&mut builder);
1685 }
1686 MarkdownTagEnd::CodeBlock => {
1687 builder.trim_trailing_newline();
1688
1689 builder.pop_div();
1690 builder.pop_code_block();
1691 builder.pop_text_style();
1692
1693 if let CodeBlockRenderer::Default {
1694 copy_button_visibility,
1695 ..
1696 } = &self.code_block_renderer
1697 && *copy_button_visibility != CopyButtonVisibility::Hidden
1698 {
1699 builder.modify_current_div(|el| {
1700 let content_range = parser::extract_code_block_content_range(
1701 &parsed_markdown.source()[range.clone()],
1702 );
1703 let content_range = content_range.start + range.start
1704 ..content_range.end + range.start;
1705
1706 let code = parsed_markdown.source()[content_range].to_string();
1707 let codeblock = render_copy_code_block_button(
1708 range.end,
1709 code,
1710 self.markdown.clone(),
1711 );
1712 el.child(
1713 h_flex()
1714 .w_4()
1715 .absolute()
1716 .justify_end()
1717 .when_else(
1718 *copy_button_visibility
1719 == CopyButtonVisibility::VisibleOnHover,
1720 |this| {
1721 this.top_0()
1722 .right_0()
1723 .visible_on_hover("code_block")
1724 },
1725 |this| this.top_1p5().right_1p5(),
1726 )
1727 .child(codeblock),
1728 )
1729 });
1730 }
1731
1732 // Pop the parent container.
1733 builder.pop_div();
1734 }
1735 MarkdownTagEnd::HtmlBlock => builder.pop_div(),
1736 MarkdownTagEnd::List(_) => {
1737 builder.pop_list();
1738 builder.pop_div();
1739 }
1740 MarkdownTagEnd::Item => {
1741 self.pop_markdown_list_item(&mut builder);
1742 }
1743 MarkdownTagEnd::Emphasis => builder.pop_text_style(),
1744 MarkdownTagEnd::Strong => builder.pop_text_style(),
1745 MarkdownTagEnd::Strikethrough => builder.pop_text_style(),
1746 MarkdownTagEnd::Link => {
1747 if builder.code_block_stack.is_empty() {
1748 builder.pop_text_style()
1749 }
1750 }
1751 MarkdownTagEnd::Table => {
1752 builder.pop_div();
1753 builder.table.end();
1754 }
1755 MarkdownTagEnd::TableHead => {
1756 builder.pop_text_style();
1757 builder.table.end_head();
1758 }
1759 MarkdownTagEnd::TableRow => {
1760 builder.table.end_row();
1761 }
1762 MarkdownTagEnd::TableCell => {
1763 builder.replace_pending_checkbox(range);
1764 builder.pop_div();
1765 builder.table.end_cell();
1766 }
1767 _ => log::debug!("unsupported markdown tag end: {:?}", tag),
1768 },
1769 MarkdownEvent::Text => {
1770 builder.push_text(&parsed_markdown.source[range.clone()], range.clone());
1771 }
1772 MarkdownEvent::SubstitutedText(text) => {
1773 builder.push_text(text, range.clone());
1774 }
1775 MarkdownEvent::Code => {
1776 builder.push_text_style(self.style.inline_code.clone());
1777 builder.push_text(&parsed_markdown.source[range.clone()], range.clone());
1778 builder.pop_text_style();
1779 }
1780 MarkdownEvent::Html => {
1781 let html = &parsed_markdown.source[range.clone()];
1782 if html.starts_with("<!--") {
1783 builder.html_comment = true;
1784 }
1785 if html.trim_end().ends_with("-->") {
1786 builder.html_comment = false;
1787 continue;
1788 }
1789 if builder.html_comment {
1790 continue;
1791 }
1792 builder.push_text(html, range.clone());
1793 }
1794 MarkdownEvent::InlineHtml => {
1795 let html = &parsed_markdown.source[range.clone()];
1796 if html.starts_with("<code>") {
1797 builder.push_text_style(self.style.inline_code.clone());
1798 continue;
1799 }
1800 if html.trim_end().starts_with("</code>") {
1801 builder.pop_text_style();
1802 continue;
1803 }
1804 builder.push_text(&parsed_markdown.source[range.clone()], range.clone());
1805 }
1806 MarkdownEvent::Rule => {
1807 builder.push_div(
1808 div()
1809 .border_b_1()
1810 .my_2()
1811 .border_color(self.style.rule_color),
1812 range,
1813 markdown_end,
1814 );
1815 builder.pop_div()
1816 }
1817 MarkdownEvent::SoftBreak => builder.push_text(" ", range.clone()),
1818 MarkdownEvent::HardBreak => builder.push_text("\n", range.clone()),
1819 MarkdownEvent::TaskListMarker(_) => {
1820 // handled inside the `MarkdownTag::Item` case
1821 }
1822 _ => log::debug!("unsupported markdown event {:?}", event),
1823 }
1824 }
1825 if self.style.code_block_overflow_x_scroll {
1826 let code_block_ids = code_block_ids;
1827 self.markdown.update(cx, move |markdown, _| {
1828 markdown.retain_code_block_scroll_handles(&code_block_ids);
1829 });
1830 } else {
1831 self.markdown
1832 .update(cx, |markdown, _| markdown.clear_code_block_scroll_handles());
1833 }
1834 let mut rendered_markdown = builder.build();
1835 let child_layout_id = rendered_markdown.element.request_layout(window, cx);
1836 let layout_id = window.request_layout(gpui::Style::default(), [child_layout_id], cx);
1837 (layout_id, rendered_markdown)
1838 }
1839
1840 fn prepaint(
1841 &mut self,
1842 _id: Option<&GlobalElementId>,
1843 _inspector_id: Option<&gpui::InspectorElementId>,
1844 bounds: Bounds<Pixels>,
1845 rendered_markdown: &mut Self::RequestLayoutState,
1846 window: &mut Window,
1847 cx: &mut App,
1848 ) -> Self::PrepaintState {
1849 let focus_handle = self.markdown.read(cx).focus_handle.clone();
1850 window.set_focus_handle(&focus_handle, cx);
1851 window.set_view_id(self.markdown.entity_id());
1852
1853 let hitbox = window.insert_hitbox(bounds, HitboxBehavior::Normal);
1854 rendered_markdown.element.prepaint(window, cx);
1855 self.autoscroll(&rendered_markdown.text, window, cx);
1856 hitbox
1857 }
1858
1859 fn paint(
1860 &mut self,
1861 _id: Option<&GlobalElementId>,
1862 _inspector_id: Option<&gpui::InspectorElementId>,
1863 bounds: Bounds<Pixels>,
1864 rendered_markdown: &mut Self::RequestLayoutState,
1865 hitbox: &mut Self::PrepaintState,
1866 window: &mut Window,
1867 cx: &mut App,
1868 ) {
1869 let mut context = KeyContext::default();
1870 context.add("Markdown");
1871 window.set_key_context(context);
1872 window.on_action(std::any::TypeId::of::<crate::Copy>(), {
1873 let entity = self.markdown.clone();
1874 let text = rendered_markdown.text.clone();
1875 move |_, phase, window, cx| {
1876 let text = text.clone();
1877 if phase == DispatchPhase::Bubble {
1878 entity.update(cx, move |this, cx| this.copy(&text, window, cx))
1879 }
1880 }
1881 });
1882 window.on_action(std::any::TypeId::of::<crate::CopyAsMarkdown>(), {
1883 let entity = self.markdown.clone();
1884 move |_, phase, window, cx| {
1885 if phase == DispatchPhase::Bubble {
1886 entity.update(cx, move |this, cx| this.copy_as_markdown(window, cx))
1887 }
1888 }
1889 });
1890
1891 self.paint_mouse_listeners(hitbox, &rendered_markdown.text, window, cx);
1892 rendered_markdown.element.paint(window, cx);
1893 self.paint_selection(bounds, &rendered_markdown.text, window, cx);
1894 }
1895}
1896
1897fn apply_heading_style(
1898 mut heading: Div,
1899 level: pulldown_cmark::HeadingLevel,
1900 custom_styles: Option<&HeadingLevelStyles>,
1901) -> Div {
1902 heading = match level {
1903 pulldown_cmark::HeadingLevel::H1 => heading.text_3xl(),
1904 pulldown_cmark::HeadingLevel::H2 => heading.text_2xl(),
1905 pulldown_cmark::HeadingLevel::H3 => heading.text_xl(),
1906 pulldown_cmark::HeadingLevel::H4 => heading.text_lg(),
1907 pulldown_cmark::HeadingLevel::H5 => heading.text_base(),
1908 pulldown_cmark::HeadingLevel::H6 => heading.text_sm(),
1909 };
1910
1911 if let Some(styles) = custom_styles {
1912 let style_opt = match level {
1913 pulldown_cmark::HeadingLevel::H1 => &styles.h1,
1914 pulldown_cmark::HeadingLevel::H2 => &styles.h2,
1915 pulldown_cmark::HeadingLevel::H3 => &styles.h3,
1916 pulldown_cmark::HeadingLevel::H4 => &styles.h4,
1917 pulldown_cmark::HeadingLevel::H5 => &styles.h5,
1918 pulldown_cmark::HeadingLevel::H6 => &styles.h6,
1919 };
1920
1921 if let Some(style) = style_opt {
1922 heading.style().text = style.clone();
1923 }
1924 }
1925
1926 heading
1927}
1928
1929fn render_copy_code_block_button(
1930 id: usize,
1931 code: String,
1932 markdown: Entity<Markdown>,
1933) -> impl IntoElement {
1934 let id = ElementId::named_usize("copy-markdown-code", id);
1935
1936 CopyButton::new(id.clone(), code.clone()).custom_on_click({
1937 let markdown = markdown;
1938 move |_window, cx| {
1939 let id = id.clone();
1940 markdown.update(cx, |this, cx| {
1941 this.copied_code_blocks.insert(id.clone());
1942
1943 cx.write_to_clipboard(ClipboardItem::new_string(code.clone()));
1944
1945 cx.spawn(async move |this, cx| {
1946 cx.background_executor().timer(Duration::from_secs(2)).await;
1947
1948 cx.update(|cx| {
1949 this.update(cx, |this, cx| {
1950 this.copied_code_blocks.remove(&id);
1951 cx.notify();
1952 })
1953 })
1954 .ok();
1955 })
1956 .detach();
1957 });
1958 }
1959 })
1960}
1961
1962impl IntoElement for MarkdownElement {
1963 type Element = Self;
1964
1965 fn into_element(self) -> Self::Element {
1966 self
1967 }
1968}
1969
1970pub enum AnyDiv {
1971 Div(Div),
1972 Stateful(Stateful<Div>),
1973}
1974
1975impl AnyDiv {
1976 fn into_any_element(self) -> AnyElement {
1977 match self {
1978 Self::Div(div) => div.into_any_element(),
1979 Self::Stateful(div) => div.into_any_element(),
1980 }
1981 }
1982}
1983
1984impl From<Div> for AnyDiv {
1985 fn from(value: Div) -> Self {
1986 Self::Div(value)
1987 }
1988}
1989
1990impl From<Stateful<Div>> for AnyDiv {
1991 fn from(value: Stateful<Div>) -> Self {
1992 Self::Stateful(value)
1993 }
1994}
1995
1996impl Styled for AnyDiv {
1997 fn style(&mut self) -> &mut StyleRefinement {
1998 match self {
1999 Self::Div(div) => div.style(),
2000 Self::Stateful(div) => div.style(),
2001 }
2002 }
2003}
2004
2005impl ParentElement for AnyDiv {
2006 fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
2007 match self {
2008 Self::Div(div) => div.extend(elements),
2009 Self::Stateful(div) => div.extend(elements),
2010 }
2011 }
2012}
2013
2014#[derive(Default)]
2015struct TableState {
2016 alignments: Vec<Alignment>,
2017 in_head: bool,
2018 row_index: usize,
2019 col_index: usize,
2020}
2021
2022impl TableState {
2023 fn start(&mut self, alignments: Vec<Alignment>) {
2024 self.alignments = alignments;
2025 self.in_head = false;
2026 self.row_index = 0;
2027 self.col_index = 0;
2028 }
2029
2030 fn end(&mut self) {
2031 self.alignments.clear();
2032 self.in_head = false;
2033 self.row_index = 0;
2034 self.col_index = 0;
2035 }
2036
2037 fn start_head(&mut self) {
2038 self.in_head = true;
2039 }
2040
2041 fn end_head(&mut self) {
2042 self.in_head = false;
2043 }
2044
2045 fn start_row(&mut self) {
2046 self.col_index = 0;
2047 }
2048
2049 fn end_row(&mut self) {
2050 self.row_index += 1;
2051 }
2052
2053 fn end_cell(&mut self) {
2054 self.col_index += 1;
2055 }
2056}
2057
2058struct MarkdownElementBuilder {
2059 div_stack: Vec<AnyDiv>,
2060 rendered_lines: Vec<RenderedLine>,
2061 pending_line: PendingLine,
2062 rendered_links: Vec<RenderedLink>,
2063 current_source_index: usize,
2064 html_comment: bool,
2065 base_text_style: TextStyle,
2066 text_style_stack: Vec<TextStyleRefinement>,
2067 code_block_stack: Vec<Option<Arc<Language>>>,
2068 list_stack: Vec<ListStackEntry>,
2069 table: TableState,
2070 syntax_theme: Arc<SyntaxTheme>,
2071}
2072
2073#[derive(Default)]
2074struct PendingLine {
2075 text: String,
2076 runs: Vec<TextRun>,
2077 source_mappings: Vec<SourceMapping>,
2078}
2079
2080struct ListStackEntry {
2081 bullet_index: Option<u64>,
2082}
2083
2084impl MarkdownElementBuilder {
2085 fn new(
2086 container_style: &StyleRefinement,
2087 base_text_style: TextStyle,
2088 syntax_theme: Arc<SyntaxTheme>,
2089 ) -> Self {
2090 Self {
2091 div_stack: vec![{
2092 let mut base_div = div();
2093 base_div.style().refine(container_style);
2094 base_div.debug_selector(|| "inner".into()).into()
2095 }],
2096 rendered_lines: Vec::new(),
2097 pending_line: PendingLine::default(),
2098 rendered_links: Vec::new(),
2099 current_source_index: 0,
2100 html_comment: false,
2101 base_text_style,
2102 text_style_stack: Vec::new(),
2103 code_block_stack: Vec::new(),
2104 list_stack: Vec::new(),
2105 table: TableState::default(),
2106 syntax_theme,
2107 }
2108 }
2109
2110 fn push_text_style(&mut self, style: TextStyleRefinement) {
2111 self.text_style_stack.push(style);
2112 }
2113
2114 fn text_style(&self) -> TextStyle {
2115 let mut style = self.base_text_style.clone();
2116 for refinement in &self.text_style_stack {
2117 style.refine(refinement);
2118 }
2119 style
2120 }
2121
2122 fn pop_text_style(&mut self) {
2123 self.text_style_stack.pop();
2124 }
2125
2126 fn push_div(&mut self, div: impl Into<AnyDiv>, range: &Range<usize>, markdown_end: usize) {
2127 let mut div = div.into();
2128 self.flush_text();
2129
2130 if range.start == 0 {
2131 // Remove the top margin on the first element.
2132 div.style().refine(&StyleRefinement {
2133 margin: gpui::EdgesRefinement {
2134 top: Some(Length::Definite(px(0.).into())),
2135 left: None,
2136 right: None,
2137 bottom: None,
2138 },
2139 ..Default::default()
2140 });
2141 }
2142
2143 if range.end == markdown_end {
2144 div.style().refine(&StyleRefinement {
2145 margin: gpui::EdgesRefinement {
2146 top: None,
2147 left: None,
2148 right: None,
2149 bottom: Some(Length::Definite(rems(0.).into())),
2150 },
2151 ..Default::default()
2152 });
2153 }
2154
2155 self.div_stack.push(div);
2156 }
2157
2158 fn push_root_block(&mut self, range: &Range<usize>, markdown_end: usize) {
2159 self.push_div(
2160 div().group("markdown-root-block").relative(),
2161 range,
2162 markdown_end,
2163 );
2164 self.push_div(div().pl_4(), range, markdown_end);
2165 }
2166
2167 fn modify_current_div(&mut self, f: impl FnOnce(AnyDiv) -> AnyDiv) {
2168 self.flush_text();
2169 if let Some(div) = self.div_stack.pop() {
2170 self.div_stack.push(f(div));
2171 }
2172 }
2173
2174 fn pop_root_block(
2175 &mut self,
2176 is_active: bool,
2177 active_gutter_color: Hsla,
2178 hovered_gutter_color: Hsla,
2179 ) {
2180 self.pop_div();
2181 self.modify_current_div(|el| {
2182 el.child(
2183 div()
2184 .h_full()
2185 .w(px(4.0))
2186 .when(is_active, |this| this.bg(active_gutter_color))
2187 .group_hover("markdown-root-block", |this| {
2188 if is_active {
2189 this
2190 } else {
2191 this.bg(hovered_gutter_color)
2192 }
2193 })
2194 .rounded_xs()
2195 .absolute()
2196 .left_0()
2197 .top_0(),
2198 )
2199 });
2200 self.pop_div();
2201 }
2202
2203 fn pop_div(&mut self) {
2204 self.flush_text();
2205 let div = self.div_stack.pop().unwrap().into_any_element();
2206 self.div_stack.last_mut().unwrap().extend(iter::once(div));
2207 }
2208
2209 fn push_sourced_element(&mut self, source_range: Range<usize>, element: impl Into<AnyElement>) {
2210 self.flush_text();
2211 let anchor = self.render_source_anchor(source_range);
2212 self.div_stack.last_mut().unwrap().extend([{
2213 div()
2214 .relative()
2215 .child(anchor)
2216 .child(element.into())
2217 .into_any_element()
2218 }]);
2219 }
2220
2221 fn push_list(&mut self, bullet_index: Option<u64>) {
2222 self.list_stack.push(ListStackEntry { bullet_index });
2223 }
2224
2225 fn next_bullet_index(&mut self) -> Option<u64> {
2226 self.list_stack.last_mut().and_then(|entry| {
2227 let item_index = entry.bullet_index.as_mut()?;
2228 *item_index += 1;
2229 Some(*item_index - 1)
2230 })
2231 }
2232
2233 fn pop_list(&mut self) {
2234 self.list_stack.pop();
2235 }
2236
2237 fn push_code_block(&mut self, language: Option<Arc<Language>>) {
2238 self.code_block_stack.push(language);
2239 }
2240
2241 fn pop_code_block(&mut self) {
2242 self.code_block_stack.pop();
2243 }
2244
2245 fn push_link(&mut self, destination_url: SharedString, source_range: Range<usize>) {
2246 self.rendered_links.push(RenderedLink {
2247 source_range,
2248 destination_url,
2249 });
2250 }
2251
2252 fn push_text(&mut self, text: &str, source_range: Range<usize>) {
2253 self.pending_line.source_mappings.push(SourceMapping {
2254 rendered_index: self.pending_line.text.len(),
2255 source_index: source_range.start,
2256 });
2257 self.pending_line.text.push_str(text);
2258 self.current_source_index = source_range.end;
2259
2260 if let Some(Some(language)) = self.code_block_stack.last() {
2261 let mut offset = 0;
2262 for (range, highlight_id) in language.highlight_text(&Rope::from(text), 0..text.len()) {
2263 if range.start > offset {
2264 self.pending_line
2265 .runs
2266 .push(self.text_style().to_run(range.start - offset));
2267 }
2268
2269 let mut run_style = self.text_style();
2270 if let Some(highlight) = self.syntax_theme.get(highlight_id).cloned() {
2271 run_style = run_style.highlight(highlight);
2272 }
2273
2274 self.pending_line.runs.push(run_style.to_run(range.len()));
2275 offset = range.end;
2276 }
2277
2278 if offset < text.len() {
2279 self.pending_line
2280 .runs
2281 .push(self.text_style().to_run(text.len() - offset));
2282 }
2283 } else {
2284 self.pending_line
2285 .runs
2286 .push(self.text_style().to_run(text.len()));
2287 }
2288 }
2289
2290 fn trim_trailing_newline(&mut self) {
2291 if self.pending_line.text.ends_with('\n') {
2292 self.pending_line
2293 .text
2294 .truncate(self.pending_line.text.len() - 1);
2295 self.pending_line.runs.last_mut().unwrap().len -= 1;
2296 self.current_source_index -= 1;
2297 }
2298 }
2299
2300 fn replace_pending_checkbox(&mut self, source_range: &Range<usize>) {
2301 let trimmed = self.pending_line.text.trim();
2302 if trimmed == "[x]" || trimmed == "[X]" || trimmed == "[ ]" {
2303 let checked = trimmed != "[ ]";
2304 self.pending_line = PendingLine::default();
2305 let checkbox = Checkbox::new(
2306 ElementId::Name(
2307 format!("table_checkbox_{}_{}", source_range.start, source_range.end).into(),
2308 ),
2309 if checked {
2310 ToggleState::Selected
2311 } else {
2312 ToggleState::Unselected
2313 },
2314 )
2315 .fill()
2316 .visualization_only(true)
2317 .into_any_element();
2318 self.div_stack.last_mut().unwrap().extend([checkbox]);
2319 }
2320 }
2321
2322 fn render_source_anchor(&mut self, source_range: Range<usize>) -> AnyElement {
2323 let mut text_style = self.base_text_style.clone();
2324 text_style.color = Hsla::transparent_black();
2325 let text = "\u{200B}";
2326 let styled_text = StyledText::new(text).with_runs(vec![text_style.to_run(text.len())]);
2327 self.rendered_lines.push(RenderedLine {
2328 layout: styled_text.layout().clone(),
2329 source_mappings: vec![SourceMapping {
2330 rendered_index: 0,
2331 source_index: source_range.start,
2332 }],
2333 source_end: source_range.end,
2334 language: None,
2335 });
2336 div()
2337 .absolute()
2338 .top_0()
2339 .left_0()
2340 .opacity(0.)
2341 .child(styled_text)
2342 .into_any_element()
2343 }
2344
2345 fn flush_text(&mut self) {
2346 let line = mem::take(&mut self.pending_line);
2347 if line.text.is_empty() {
2348 return;
2349 }
2350
2351 let text = StyledText::new(line.text).with_runs(line.runs);
2352 self.rendered_lines.push(RenderedLine {
2353 layout: text.layout().clone(),
2354 source_mappings: line.source_mappings,
2355 source_end: self.current_source_index,
2356 language: self.code_block_stack.last().cloned().flatten(),
2357 });
2358 self.div_stack.last_mut().unwrap().extend([text.into_any()]);
2359 }
2360
2361 fn build(mut self) -> RenderedMarkdown {
2362 debug_assert_eq!(self.div_stack.len(), 1);
2363 self.flush_text();
2364 RenderedMarkdown {
2365 element: self.div_stack.pop().unwrap().into_any_element(),
2366 text: RenderedText {
2367 lines: self.rendered_lines.into(),
2368 links: self.rendered_links.into(),
2369 },
2370 }
2371 }
2372}
2373
2374struct RenderedLine {
2375 layout: TextLayout,
2376 source_mappings: Vec<SourceMapping>,
2377 source_end: usize,
2378 language: Option<Arc<Language>>,
2379}
2380
2381impl RenderedLine {
2382 fn rendered_index_for_source_index(&self, source_index: usize) -> usize {
2383 if source_index >= self.source_end {
2384 return self.layout.len();
2385 }
2386
2387 let mapping = match self
2388 .source_mappings
2389 .binary_search_by_key(&source_index, |probe| probe.source_index)
2390 {
2391 Ok(ix) => &self.source_mappings[ix],
2392 Err(ix) => &self.source_mappings[ix - 1],
2393 };
2394 (mapping.rendered_index + (source_index - mapping.source_index)).min(self.layout.len())
2395 }
2396
2397 fn source_index_for_rendered_index(&self, rendered_index: usize) -> usize {
2398 if rendered_index >= self.layout.len() {
2399 return self.source_end;
2400 }
2401
2402 let mapping = match self
2403 .source_mappings
2404 .binary_search_by_key(&rendered_index, |probe| probe.rendered_index)
2405 {
2406 Ok(ix) => &self.source_mappings[ix],
2407 Err(ix) => &self.source_mappings[ix - 1],
2408 };
2409 mapping.source_index + (rendered_index - mapping.rendered_index)
2410 }
2411
2412 /// Returns the source index for use as an exclusive range end at a word/selection boundary.
2413 /// When the rendered index is exactly at the start of a segment with a gap from the previous
2414 /// segment (e.g., after stripped markdown syntax like backticks), this returns the end of the
2415 /// previous segment rather than the start of the current one.
2416 fn source_index_for_exclusive_rendered_end(&self, rendered_index: usize) -> usize {
2417 if rendered_index >= self.layout.len() {
2418 return self.source_end;
2419 }
2420
2421 let ix = match self
2422 .source_mappings
2423 .binary_search_by_key(&rendered_index, |probe| probe.rendered_index)
2424 {
2425 Ok(ix) => ix,
2426 Err(ix) => {
2427 return self.source_mappings[ix - 1].source_index
2428 + (rendered_index - self.source_mappings[ix - 1].rendered_index);
2429 }
2430 };
2431
2432 // Exact match at the start of a segment. Check if there's a gap from the previous segment.
2433 if ix > 0 {
2434 let prev_mapping = &self.source_mappings[ix - 1];
2435 let mapping = &self.source_mappings[ix];
2436 let prev_segment_len = mapping.rendered_index - prev_mapping.rendered_index;
2437 let prev_source_end = prev_mapping.source_index + prev_segment_len;
2438 if prev_source_end < mapping.source_index {
2439 return prev_source_end;
2440 }
2441 }
2442
2443 self.source_mappings[ix].source_index
2444 }
2445
2446 fn source_index_for_position(&self, position: Point<Pixels>) -> Result<usize, usize> {
2447 let line_rendered_index;
2448 let out_of_bounds;
2449 match self.layout.index_for_position(position) {
2450 Ok(ix) => {
2451 line_rendered_index = ix;
2452 out_of_bounds = false;
2453 }
2454 Err(ix) => {
2455 line_rendered_index = ix;
2456 out_of_bounds = true;
2457 }
2458 };
2459 let source_index = self.source_index_for_rendered_index(line_rendered_index);
2460 if out_of_bounds {
2461 Err(source_index)
2462 } else {
2463 Ok(source_index)
2464 }
2465 }
2466}
2467
2468#[derive(Copy, Clone, Debug, Default)]
2469struct SourceMapping {
2470 rendered_index: usize,
2471 source_index: usize,
2472}
2473
2474pub struct RenderedMarkdown {
2475 element: AnyElement,
2476 text: RenderedText,
2477}
2478
2479#[derive(Clone)]
2480struct RenderedText {
2481 lines: Rc<[RenderedLine]>,
2482 links: Rc<[RenderedLink]>,
2483}
2484
2485#[derive(Debug, Clone, Eq, PartialEq)]
2486struct RenderedLink {
2487 source_range: Range<usize>,
2488 destination_url: SharedString,
2489}
2490
2491impl RenderedText {
2492 fn source_index_for_position(&self, position: Point<Pixels>) -> Result<usize, usize> {
2493 let mut lines = self.lines.iter().peekable();
2494 let mut fallback_line: Option<&RenderedLine> = None;
2495
2496 while let Some(line) = lines.next() {
2497 let line_bounds = line.layout.bounds();
2498
2499 // Exact match: position is within bounds (handles overlapping bounds like table columns)
2500 if line_bounds.contains(&position) {
2501 return line.source_index_for_position(position);
2502 }
2503
2504 // Track fallback for Y-coordinate based matching
2505 if position.y <= line_bounds.bottom() && fallback_line.is_none() {
2506 fallback_line = Some(line);
2507 }
2508
2509 // Handle gap between lines
2510 if position.y > line_bounds.bottom() {
2511 if let Some(next_line) = lines.peek()
2512 && position.y < next_line.layout.bounds().top()
2513 {
2514 return Err(line.source_end);
2515 }
2516 }
2517 }
2518
2519 // Fall back to Y-coordinate matched line
2520 if let Some(line) = fallback_line {
2521 return line.source_index_for_position(position);
2522 }
2523
2524 Err(self.lines.last().map_or(0, |line| line.source_end))
2525 }
2526
2527 fn position_for_source_index(&self, source_index: usize) -> Option<(Point<Pixels>, Pixels)> {
2528 for line in self.lines.iter() {
2529 let line_source_start = line.source_mappings.first().unwrap().source_index;
2530 if source_index < line_source_start {
2531 break;
2532 } else if source_index > line.source_end {
2533 continue;
2534 } else {
2535 let line_height = line.layout.line_height();
2536 let rendered_index_within_line = line.rendered_index_for_source_index(source_index);
2537 let position = line.layout.position_for_index(rendered_index_within_line)?;
2538 return Some((position, line_height));
2539 }
2540 }
2541 None
2542 }
2543
2544 fn surrounding_word_range(&self, source_index: usize) -> Range<usize> {
2545 for line in self.lines.iter() {
2546 if source_index > line.source_end {
2547 continue;
2548 }
2549
2550 let line_rendered_start = line.source_mappings.first().unwrap().rendered_index;
2551 let rendered_index_in_line =
2552 line.rendered_index_for_source_index(source_index) - line_rendered_start;
2553 let text = line.layout.text();
2554
2555 let scope = line.language.as_ref().map(|l| l.default_scope());
2556 let classifier = CharClassifier::new(scope);
2557
2558 let mut prev_chars = text[..rendered_index_in_line].chars().rev().peekable();
2559 let mut next_chars = text[rendered_index_in_line..].chars().peekable();
2560
2561 let word_kind = std::cmp::max(
2562 prev_chars.peek().map(|&c| classifier.kind(c)),
2563 next_chars.peek().map(|&c| classifier.kind(c)),
2564 );
2565
2566 let mut start = rendered_index_in_line;
2567 for c in prev_chars {
2568 if Some(classifier.kind(c)) == word_kind {
2569 start -= c.len_utf8();
2570 } else {
2571 break;
2572 }
2573 }
2574
2575 let mut end = rendered_index_in_line;
2576 for c in next_chars {
2577 if Some(classifier.kind(c)) == word_kind {
2578 end += c.len_utf8();
2579 } else {
2580 break;
2581 }
2582 }
2583
2584 return line.source_index_for_rendered_index(line_rendered_start + start)
2585 ..line.source_index_for_exclusive_rendered_end(line_rendered_start + end);
2586 }
2587
2588 source_index..source_index
2589 }
2590
2591 fn surrounding_line_range(&self, source_index: usize) -> Range<usize> {
2592 for line in self.lines.iter() {
2593 if source_index > line.source_end {
2594 continue;
2595 }
2596 let line_source_start = line.source_mappings.first().unwrap().source_index;
2597 return line_source_start..line.source_end;
2598 }
2599
2600 source_index..source_index
2601 }
2602
2603 fn text_for_range(&self, range: Range<usize>) -> String {
2604 let mut accumulator = String::new();
2605
2606 for line in self.lines.iter() {
2607 if range.start > line.source_end {
2608 continue;
2609 }
2610 let line_source_start = line.source_mappings.first().unwrap().source_index;
2611 if range.end < line_source_start {
2612 break;
2613 }
2614
2615 let text = line.layout.text();
2616
2617 let start = if range.start < line_source_start {
2618 0
2619 } else {
2620 line.rendered_index_for_source_index(range.start)
2621 };
2622 let end = if range.end > line.source_end {
2623 line.rendered_index_for_source_index(line.source_end)
2624 } else {
2625 line.rendered_index_for_source_index(range.end)
2626 }
2627 .min(text.len());
2628
2629 accumulator.push_str(&text[start..end]);
2630 accumulator.push('\n');
2631 }
2632 // Remove trailing newline
2633 accumulator.pop();
2634 accumulator
2635 }
2636
2637 fn link_for_position(&self, position: Point<Pixels>) -> Option<&RenderedLink> {
2638 let source_index = self.source_index_for_position(position).ok()?;
2639 self.links
2640 .iter()
2641 .find(|link| link.source_range.contains(&source_index))
2642 }
2643}
2644
2645#[cfg(test)]
2646mod tests {
2647 use super::*;
2648 use gpui::{TestAppContext, size};
2649 use language::{Language, LanguageConfig, LanguageMatcher};
2650 use std::sync::Arc;
2651
2652 fn ensure_theme_initialized(cx: &mut TestAppContext) {
2653 cx.update(|cx| {
2654 if !cx.has_global::<settings::SettingsStore>() {
2655 settings::init(cx);
2656 }
2657 if !cx.has_global::<theme::GlobalTheme>() {
2658 theme_settings::init(theme::LoadThemes::JustBase, cx);
2659 }
2660 });
2661 }
2662
2663 #[gpui::test]
2664 fn test_mappings(cx: &mut TestAppContext) {
2665 // Formatting.
2666 assert_mappings(
2667 &render_markdown("He*l*lo", cx),
2668 vec![vec![(0, 0), (1, 1), (2, 3), (3, 5), (4, 6), (5, 7)]],
2669 );
2670
2671 // Multiple lines.
2672 assert_mappings(
2673 &render_markdown("Hello\n\nWorld", cx),
2674 vec![
2675 vec![(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5)],
2676 vec![(0, 7), (1, 8), (2, 9), (3, 10), (4, 11), (5, 12)],
2677 ],
2678 );
2679
2680 // Multi-byte characters.
2681 assert_mappings(
2682 &render_markdown("αβγ\n\nδεζ", cx),
2683 vec![
2684 vec![(0, 0), (2, 2), (4, 4), (6, 6)],
2685 vec![(0, 8), (2, 10), (4, 12), (6, 14)],
2686 ],
2687 );
2688
2689 // Smart quotes.
2690 assert_mappings(&render_markdown("\"", cx), vec![vec![(0, 0), (3, 1)]]);
2691 assert_mappings(
2692 &render_markdown("\"hey\"", cx),
2693 vec![vec![(0, 0), (3, 1), (4, 2), (5, 3), (6, 4), (9, 5)]],
2694 );
2695
2696 // HTML Comments are ignored
2697 assert_mappings(
2698 &render_markdown(
2699 "<!--\nrdoc-file=string.c\n- str.intern -> symbol\n- str.to_sym -> symbol\n-->\nReturns",
2700 cx,
2701 ),
2702 vec![vec![
2703 (0, 78),
2704 (1, 79),
2705 (2, 80),
2706 (3, 81),
2707 (4, 82),
2708 (5, 83),
2709 (6, 84),
2710 ]],
2711 );
2712 }
2713
2714 fn render_markdown(markdown: &str, cx: &mut TestAppContext) -> RenderedText {
2715 render_markdown_with_language_registry(markdown, None, cx)
2716 }
2717
2718 fn render_markdown_with_language_registry(
2719 markdown: &str,
2720 language_registry: Option<Arc<LanguageRegistry>>,
2721 cx: &mut TestAppContext,
2722 ) -> RenderedText {
2723 render_markdown_with_options(markdown, language_registry, MarkdownOptions::default(), cx)
2724 }
2725
2726 fn render_markdown_with_options(
2727 markdown: &str,
2728 language_registry: Option<Arc<LanguageRegistry>>,
2729 options: MarkdownOptions,
2730 cx: &mut TestAppContext,
2731 ) -> RenderedText {
2732 struct TestWindow;
2733
2734 impl Render for TestWindow {
2735 fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
2736 div()
2737 }
2738 }
2739
2740 ensure_theme_initialized(cx);
2741
2742 let (_, cx) = cx.add_window_view(|_, _| TestWindow);
2743 let markdown = cx.new(|cx| {
2744 Markdown::new_with_options(
2745 markdown.to_string().into(),
2746 language_registry,
2747 None,
2748 options,
2749 cx,
2750 )
2751 });
2752 cx.run_until_parked();
2753 let (rendered, _) = cx.draw(
2754 Default::default(),
2755 size(px(600.0), px(600.0)),
2756 |_window, _cx| {
2757 MarkdownElement::new(markdown, MarkdownStyle::default()).code_block_renderer(
2758 CodeBlockRenderer::Default {
2759 copy_button_visibility: CopyButtonVisibility::Hidden,
2760 border: false,
2761 },
2762 )
2763 },
2764 );
2765 rendered.text
2766 }
2767
2768 #[gpui::test]
2769 fn test_surrounding_word_range(cx: &mut TestAppContext) {
2770 let rendered = render_markdown("Hello world tesεζ", cx);
2771
2772 // Test word selection for "Hello"
2773 let word_range = rendered.surrounding_word_range(2); // Simulate click on 'l' in "Hello"
2774 let selected_text = rendered.text_for_range(word_range);
2775 assert_eq!(selected_text, "Hello");
2776
2777 // Test word selection for "world"
2778 let word_range = rendered.surrounding_word_range(7); // Simulate click on 'o' in "world"
2779 let selected_text = rendered.text_for_range(word_range);
2780 assert_eq!(selected_text, "world");
2781
2782 // Test word selection for "tesεζ"
2783 let word_range = rendered.surrounding_word_range(14); // Simulate click on 's' in "tesεζ"
2784 let selected_text = rendered.text_for_range(word_range);
2785 assert_eq!(selected_text, "tesεζ");
2786
2787 // Test word selection at word boundary (space)
2788 let word_range = rendered.surrounding_word_range(5); // Simulate click on space between "Hello" and "world", expect highlighting word to the left
2789 let selected_text = rendered.text_for_range(word_range);
2790 assert_eq!(selected_text, "Hello");
2791 }
2792
2793 #[gpui::test]
2794 fn test_surrounding_line_range(cx: &mut TestAppContext) {
2795 let rendered = render_markdown("First line\n\nSecond line\n\nThird lineεζ", cx);
2796
2797 // Test getting line range for first line
2798 let line_range = rendered.surrounding_line_range(5); // Simulate click somewhere in first line
2799 let selected_text = rendered.text_for_range(line_range);
2800 assert_eq!(selected_text, "First line");
2801
2802 // Test getting line range for second line
2803 let line_range = rendered.surrounding_line_range(13); // Simulate click at beginning in second line
2804 let selected_text = rendered.text_for_range(line_range);
2805 assert_eq!(selected_text, "Second line");
2806
2807 // Test getting line range for third line
2808 let line_range = rendered.surrounding_line_range(37); // Simulate click at end of third line with multi-byte chars
2809 let selected_text = rendered.text_for_range(line_range);
2810 assert_eq!(selected_text, "Third lineεζ");
2811 }
2812
2813 #[gpui::test]
2814 fn test_selection_head_movement(cx: &mut TestAppContext) {
2815 let rendered = render_markdown("Hello world test", cx);
2816
2817 let mut selection = Selection {
2818 start: 5,
2819 end: 5,
2820 reversed: false,
2821 pending: false,
2822 mode: SelectMode::Character,
2823 };
2824
2825 // Test forward selection
2826 selection.set_head(10, &rendered);
2827 assert_eq!(selection.start, 5);
2828 assert_eq!(selection.end, 10);
2829 assert!(!selection.reversed);
2830 assert_eq!(selection.tail(), 5);
2831
2832 // Test backward selection
2833 selection.set_head(2, &rendered);
2834 assert_eq!(selection.start, 2);
2835 assert_eq!(selection.end, 5);
2836 assert!(selection.reversed);
2837 assert_eq!(selection.tail(), 5);
2838
2839 // Test forward selection again from reversed state
2840 selection.set_head(15, &rendered);
2841 assert_eq!(selection.start, 5);
2842 assert_eq!(selection.end, 15);
2843 assert!(!selection.reversed);
2844 assert_eq!(selection.tail(), 5);
2845 }
2846
2847 #[gpui::test]
2848 fn test_word_selection_drag(cx: &mut TestAppContext) {
2849 let rendered = render_markdown("Hello world test", cx);
2850
2851 // Start with a simulated double-click on "world" (index 6-10)
2852 let word_range = rendered.surrounding_word_range(7); // Click on 'o' in "world"
2853 let mut selection = Selection {
2854 start: word_range.start,
2855 end: word_range.end,
2856 reversed: false,
2857 pending: true,
2858 mode: SelectMode::Word(word_range),
2859 };
2860
2861 // Drag forward to "test" - should expand selection to include "test"
2862 selection.set_head(13, &rendered); // Index in "test"
2863 assert_eq!(selection.start, 6); // Start of "world"
2864 assert_eq!(selection.end, 16); // End of "test"
2865 assert!(!selection.reversed);
2866 let selected_text = rendered.text_for_range(selection.start..selection.end);
2867 assert_eq!(selected_text, "world test");
2868
2869 // Drag backward to "Hello" - should expand selection to include "Hello"
2870 selection.set_head(2, &rendered); // Index in "Hello"
2871 assert_eq!(selection.start, 0); // Start of "Hello"
2872 assert_eq!(selection.end, 11); // End of "world" (original selection)
2873 assert!(selection.reversed);
2874 let selected_text = rendered.text_for_range(selection.start..selection.end);
2875 assert_eq!(selected_text, "Hello world");
2876
2877 // Drag back within original word - should revert to original selection
2878 selection.set_head(8, &rendered); // Back within "world"
2879 assert_eq!(selection.start, 6); // Start of "world"
2880 assert_eq!(selection.end, 11); // End of "world"
2881 assert!(!selection.reversed);
2882 let selected_text = rendered.text_for_range(selection.start..selection.end);
2883 assert_eq!(selected_text, "world");
2884 }
2885
2886 #[gpui::test]
2887 fn test_selection_with_markdown_formatting(cx: &mut TestAppContext) {
2888 let rendered = render_markdown(
2889 "This is **bold** text, this is *italic* text, use `code` here",
2890 cx,
2891 );
2892 let word_range = rendered.surrounding_word_range(10); // Inside "bold"
2893 let selected_text = rendered.text_for_range(word_range);
2894 assert_eq!(selected_text, "bold");
2895
2896 let word_range = rendered.surrounding_word_range(32); // Inside "italic"
2897 let selected_text = rendered.text_for_range(word_range);
2898 assert_eq!(selected_text, "italic");
2899
2900 let word_range = rendered.surrounding_word_range(51); // Inside "code"
2901 let selected_text = rendered.text_for_range(word_range);
2902 assert_eq!(selected_text, "code");
2903 }
2904
2905 #[gpui::test]
2906 fn test_table_column_selection(cx: &mut TestAppContext) {
2907 let rendered = render_markdown("| a | b |\n|---|---|\n| c | d |", cx);
2908
2909 assert!(rendered.lines.len() >= 2);
2910 let first_bounds = rendered.lines[0].layout.bounds();
2911 let second_bounds = rendered.lines[1].layout.bounds();
2912
2913 let first_index = match rendered.source_index_for_position(first_bounds.center()) {
2914 Ok(index) | Err(index) => index,
2915 };
2916 let second_index = match rendered.source_index_for_position(second_bounds.center()) {
2917 Ok(index) | Err(index) => index,
2918 };
2919
2920 let first_word = rendered.text_for_range(rendered.surrounding_word_range(first_index));
2921 let second_word = rendered.text_for_range(rendered.surrounding_word_range(second_index));
2922
2923 assert_eq!(first_word, "a");
2924 assert_eq!(second_word, "b");
2925 }
2926
2927 #[test]
2928 fn test_table_checkbox_detection() {
2929 let md = "| Done |\n|------|\n| [x] |\n| [ ] |";
2930 let events = crate::parser::parse_markdown_with_options(md, false).events;
2931
2932 let mut in_table = false;
2933 let mut cell_texts: Vec<String> = Vec::new();
2934 let mut current_cell = String::new();
2935
2936 for (range, event) in &events {
2937 match event {
2938 MarkdownEvent::Start(MarkdownTag::Table(_)) => in_table = true,
2939 MarkdownEvent::End(MarkdownTagEnd::Table) => in_table = false,
2940 MarkdownEvent::Start(MarkdownTag::TableCell) => current_cell.clear(),
2941 MarkdownEvent::End(MarkdownTagEnd::TableCell) => {
2942 if in_table {
2943 cell_texts.push(current_cell.clone());
2944 }
2945 }
2946 MarkdownEvent::Text if in_table => {
2947 current_cell.push_str(&md[range.clone()]);
2948 }
2949 _ => {}
2950 }
2951 }
2952
2953 let checkbox_cells: Vec<&String> = cell_texts
2954 .iter()
2955 .filter(|t| {
2956 let trimmed = t.trim();
2957 trimmed == "[x]" || trimmed == "[X]" || trimmed == "[ ]"
2958 })
2959 .collect();
2960 assert_eq!(
2961 checkbox_cells.len(),
2962 2,
2963 "Expected 2 checkbox cells, got: {cell_texts:?}"
2964 );
2965 assert_eq!(checkbox_cells[0].trim(), "[x]");
2966 assert_eq!(checkbox_cells[1].trim(), "[ ]");
2967 }
2968
2969 #[gpui::test]
2970 fn test_inline_code_word_selection_excludes_backticks(cx: &mut TestAppContext) {
2971 // Test that double-clicking on inline code selects just the code content,
2972 // not the backticks. This verifies the fix for the bug where selecting
2973 // inline code would include the trailing backtick.
2974 let rendered = render_markdown("use `blah` here", cx);
2975
2976 // Source layout: "use `blah` here"
2977 // 0123456789...
2978 // The inline code "blah" is at source positions 5-8 (content range 5..9)
2979
2980 // Click inside "blah" - should select just "blah", not "blah`"
2981 let word_range = rendered.surrounding_word_range(6); // 'l' in "blah"
2982
2983 // text_for_range extracts from the rendered text (without backticks), so it
2984 // would return "blah" even with a wrong source range. We check it anyway.
2985 let selected_text = rendered.text_for_range(word_range.clone());
2986 assert_eq!(selected_text, "blah");
2987
2988 // The source range is what matters for copy_as_markdown and selected_text,
2989 // which extract directly from the source. With the bug, this would be 5..10
2990 // which includes the closing backtick at position 9.
2991 assert_eq!(word_range, 5..9);
2992 }
2993
2994 #[gpui::test]
2995 fn test_surrounding_word_range_respects_word_characters(cx: &mut TestAppContext) {
2996 let rendered = render_markdown("foo.bar() baz", cx);
2997
2998 // Double clicking on 'f' in "foo" - should select just "foo"
2999 let word_range = rendered.surrounding_word_range(0);
3000 let selected_text = rendered.text_for_range(word_range);
3001 assert_eq!(selected_text, "foo");
3002
3003 // Double clicking on 'b' in "bar" - should select just "bar"
3004 let word_range = rendered.surrounding_word_range(4);
3005 let selected_text = rendered.text_for_range(word_range);
3006 assert_eq!(selected_text, "bar");
3007
3008 // Double clicking on 'b' in "baz" - should select "baz"
3009 let word_range = rendered.surrounding_word_range(10);
3010 let selected_text = rendered.text_for_range(word_range);
3011 assert_eq!(selected_text, "baz");
3012
3013 // Double clicking selects word characters in code blocks
3014 let javascript_language = Arc::new(Language::new(
3015 LanguageConfig {
3016 name: "JavaScript".into(),
3017 matcher: LanguageMatcher {
3018 path_suffixes: vec!["js".to_string()],
3019 ..Default::default()
3020 },
3021 word_characters: ['$', '#'].into_iter().collect(),
3022 ..Default::default()
3023 },
3024 None,
3025 ));
3026
3027 let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
3028 language_registry.add(javascript_language);
3029
3030 let rendered = render_markdown_with_language_registry(
3031 "```javascript\n$foo #bar\n```",
3032 Some(language_registry),
3033 cx,
3034 );
3035
3036 let word_range = rendered.surrounding_word_range(14);
3037 let selected_text = rendered.text_for_range(word_range);
3038 assert_eq!(selected_text, "$foo");
3039
3040 let word_range = rendered.surrounding_word_range(19);
3041 let selected_text = rendered.text_for_range(word_range);
3042 assert_eq!(selected_text, "#bar");
3043 }
3044
3045 #[gpui::test]
3046 fn test_all_selection(cx: &mut TestAppContext) {
3047 let rendered = render_markdown("Hello world\n\nThis is a test\n\nwith multiple lines", cx);
3048
3049 let total_length = rendered
3050 .lines
3051 .last()
3052 .map(|line| line.source_end)
3053 .unwrap_or(0);
3054
3055 let mut selection = Selection {
3056 start: 0,
3057 end: total_length,
3058 reversed: false,
3059 pending: true,
3060 mode: SelectMode::All,
3061 };
3062
3063 selection.set_head(5, &rendered); // Try to set head in middle
3064 assert_eq!(selection.start, 0);
3065 assert_eq!(selection.end, total_length);
3066 assert!(!selection.reversed);
3067
3068 selection.set_head(25, &rendered); // Try to set head near end
3069 assert_eq!(selection.start, 0);
3070 assert_eq!(selection.end, total_length);
3071 assert!(!selection.reversed);
3072
3073 let selected_text = rendered.text_for_range(selection.start..selection.end);
3074 assert_eq!(
3075 selected_text,
3076 "Hello world\nThis is a test\nwith multiple lines"
3077 );
3078 }
3079
3080 #[test]
3081 fn test_escape() {
3082 assert_eq!(Markdown::escape("hello `world`"), "hello \\`world\\`");
3083 assert_eq!(
3084 Markdown::escape("hello\n cool world"),
3085 "hello\n\ncool world"
3086 );
3087 }
3088
3089 #[track_caller]
3090 fn assert_mappings(rendered: &RenderedText, expected: Vec<Vec<(usize, usize)>>) {
3091 assert_eq!(rendered.lines.len(), expected.len(), "line count mismatch");
3092 for (line_ix, line_mappings) in expected.into_iter().enumerate() {
3093 let line = &rendered.lines[line_ix];
3094
3095 assert!(
3096 line.source_mappings.windows(2).all(|mappings| {
3097 mappings[0].source_index < mappings[1].source_index
3098 && mappings[0].rendered_index < mappings[1].rendered_index
3099 }),
3100 "line {} has duplicate mappings: {:?}",
3101 line_ix,
3102 line.source_mappings
3103 );
3104
3105 for (rendered_ix, source_ix) in line_mappings {
3106 assert_eq!(
3107 line.source_index_for_rendered_index(rendered_ix),
3108 source_ix,
3109 "line {}, rendered_ix {}",
3110 line_ix,
3111 rendered_ix
3112 );
3113
3114 assert_eq!(
3115 line.rendered_index_for_source_index(source_ix),
3116 rendered_ix,
3117 "line {}, source_ix {}",
3118 line_ix,
3119 source_ix
3120 );
3121 }
3122 }
3123 }
3124}