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