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