1use crate::markdown_elements::{
2 HeadingLevel, Link, ParsedMarkdown, ParsedMarkdownBlockQuote, ParsedMarkdownCodeBlock,
3 ParsedMarkdownElement, ParsedMarkdownHeading, ParsedMarkdownList, ParsedMarkdownListItemType,
4 ParsedMarkdownTable, ParsedMarkdownTableAlignment, ParsedMarkdownTableRow, ParsedMarkdownText,
5};
6use gpui::{
7 div, px, rems, AbsoluteLength, AnyElement, DefiniteLength, Div, Element, ElementId,
8 HighlightStyle, Hsla, InteractiveText, IntoElement, ParentElement, SharedString, Styled,
9 StyledText, TextStyle, WeakView, WindowContext,
10};
11use std::{
12 ops::{Mul, Range},
13 sync::Arc,
14};
15use theme::{ActiveTheme, SyntaxTheme};
16use ui::{h_flex, v_flex, Label};
17use workspace::Workspace;
18
19pub struct RenderContext {
20 workspace: Option<WeakView<Workspace>>,
21 next_id: usize,
22 text_style: TextStyle,
23 border_color: Hsla,
24 text_color: Hsla,
25 text_muted_color: Hsla,
26 code_block_background_color: Hsla,
27 code_span_background_color: Hsla,
28 syntax_theme: Arc<SyntaxTheme>,
29 indent: usize,
30}
31
32impl RenderContext {
33 pub fn new(workspace: Option<WeakView<Workspace>>, cx: &WindowContext) -> RenderContext {
34 let theme = cx.theme().clone();
35
36 RenderContext {
37 workspace,
38 next_id: 0,
39 indent: 0,
40 text_style: cx.text_style(),
41 syntax_theme: theme.syntax().clone(),
42 border_color: theme.colors().border,
43 text_color: theme.colors().text,
44 text_muted_color: theme.colors().text_muted,
45 code_block_background_color: theme.colors().surface_background,
46 code_span_background_color: theme.colors().editor_document_highlight_read_background,
47 }
48 }
49
50 fn next_id(&mut self, span: &Range<usize>) -> ElementId {
51 let id = format!("markdown-{}-{}-{}", self.next_id, span.start, span.end);
52 self.next_id += 1;
53 ElementId::from(SharedString::from(id))
54 }
55
56 /// This ensures that children inside of block quotes
57 /// have padding between them.
58 ///
59 /// For example, for this markdown:
60 ///
61 /// ```markdown
62 /// > This is a block quote.
63 /// >
64 /// > And this is the next paragraph.
65 /// ```
66 ///
67 /// We give padding between "This is a block quote."
68 /// and "And this is the next paragraph."
69 fn with_common_p(&self, element: Div) -> Div {
70 if self.indent > 0 {
71 element.pb_3()
72 } else {
73 element
74 }
75 }
76}
77
78pub fn render_parsed_markdown(
79 parsed: &ParsedMarkdown,
80 workspace: Option<WeakView<Workspace>>,
81 cx: &WindowContext,
82) -> Vec<AnyElement> {
83 let mut cx = RenderContext::new(workspace, cx);
84 let mut elements = Vec::new();
85
86 for child in &parsed.children {
87 elements.push(render_markdown_block(child, &mut cx));
88 }
89
90 return elements;
91}
92
93pub fn render_markdown_block(block: &ParsedMarkdownElement, cx: &mut RenderContext) -> AnyElement {
94 use ParsedMarkdownElement::*;
95 match block {
96 Paragraph(text) => render_markdown_paragraph(text, cx),
97 Heading(heading) => render_markdown_heading(heading, cx),
98 List(list) => render_markdown_list(list, cx),
99 Table(table) => render_markdown_table(table, cx),
100 BlockQuote(block_quote) => render_markdown_block_quote(block_quote, cx),
101 CodeBlock(code_block) => render_markdown_code_block(code_block, cx),
102 HorizontalRule(_) => render_markdown_rule(cx),
103 }
104}
105
106fn render_markdown_heading(parsed: &ParsedMarkdownHeading, cx: &mut RenderContext) -> AnyElement {
107 let size = match parsed.level {
108 HeadingLevel::H1 => rems(2.),
109 HeadingLevel::H2 => rems(1.5),
110 HeadingLevel::H3 => rems(1.25),
111 HeadingLevel::H4 => rems(1.),
112 HeadingLevel::H5 => rems(0.875),
113 HeadingLevel::H6 => rems(0.85),
114 };
115
116 let color = match parsed.level {
117 HeadingLevel::H6 => cx.text_muted_color,
118 _ => cx.text_color,
119 };
120
121 let line_height = DefiniteLength::from(size.mul(1.25));
122
123 div()
124 .line_height(line_height)
125 .text_size(size)
126 .text_color(color)
127 .pt(rems(0.15))
128 .pb_1()
129 .child(render_markdown_text(&parsed.contents, cx))
130 .whitespace_normal()
131 .into_any()
132}
133
134fn render_markdown_list(parsed: &ParsedMarkdownList, cx: &mut RenderContext) -> AnyElement {
135 use ParsedMarkdownListItemType::*;
136
137 let mut items = vec![];
138 for item in &parsed.children {
139 let padding = rems((item.depth - 1) as f32 * 0.25);
140
141 let bullet = match item.item_type {
142 Ordered(order) => format!("{}.", order),
143 Unordered => "•".to_string(),
144 Task(checked) => if checked { "☑" } else { "☐" }.to_string(),
145 };
146 let bullet = div().mr_2().child(Label::new(bullet));
147
148 let contents: Vec<AnyElement> = item
149 .contents
150 .iter()
151 .map(|c| render_markdown_block(c.as_ref(), cx))
152 .collect();
153
154 let item = h_flex()
155 .pl(DefiniteLength::Absolute(AbsoluteLength::Rems(padding)))
156 .items_start()
157 .children(vec![bullet, div().children(contents).pr_4().w_full()]);
158
159 items.push(item);
160 }
161
162 cx.with_common_p(div()).children(items).into_any()
163}
164
165fn render_markdown_table(parsed: &ParsedMarkdownTable, cx: &mut RenderContext) -> AnyElement {
166 let header = render_markdown_table_row(&parsed.header, &parsed.column_alignments, true, cx);
167
168 let body: Vec<AnyElement> = parsed
169 .body
170 .iter()
171 .map(|row| render_markdown_table_row(row, &parsed.column_alignments, false, cx))
172 .collect();
173
174 cx.with_common_p(v_flex())
175 .w_full()
176 .child(header)
177 .children(body)
178 .into_any()
179}
180
181fn render_markdown_table_row(
182 parsed: &ParsedMarkdownTableRow,
183 alignments: &Vec<ParsedMarkdownTableAlignment>,
184 is_header: bool,
185 cx: &mut RenderContext,
186) -> AnyElement {
187 let mut items = vec![];
188
189 for cell in &parsed.children {
190 let alignment = alignments
191 .get(items.len())
192 .copied()
193 .unwrap_or(ParsedMarkdownTableAlignment::None);
194
195 let contents = render_markdown_text(cell, cx);
196
197 let container = match alignment {
198 ParsedMarkdownTableAlignment::Left | ParsedMarkdownTableAlignment::None => div(),
199 ParsedMarkdownTableAlignment::Center => v_flex().items_center(),
200 ParsedMarkdownTableAlignment::Right => v_flex().items_end(),
201 };
202
203 let mut cell = container
204 .w_full()
205 .child(contents)
206 .px_2()
207 .py_1()
208 .border_color(cx.border_color);
209
210 if is_header {
211 cell = cell.border_2()
212 } else {
213 cell = cell.border_1()
214 }
215
216 items.push(cell);
217 }
218
219 h_flex().children(items).into_any_element()
220}
221
222fn render_markdown_block_quote(
223 parsed: &ParsedMarkdownBlockQuote,
224 cx: &mut RenderContext,
225) -> AnyElement {
226 cx.indent += 1;
227
228 let children: Vec<AnyElement> = parsed
229 .children
230 .iter()
231 .map(|child| render_markdown_block(child, cx))
232 .collect();
233
234 cx.indent -= 1;
235
236 cx.with_common_p(div())
237 .child(
238 div()
239 .border_l_4()
240 .border_color(cx.border_color)
241 .pl_3()
242 .children(children),
243 )
244 .into_any()
245}
246
247fn render_markdown_code_block(
248 parsed: &ParsedMarkdownCodeBlock,
249 cx: &mut RenderContext,
250) -> AnyElement {
251 cx.with_common_p(div())
252 .px_3()
253 .py_3()
254 .bg(cx.code_block_background_color)
255 .child(StyledText::new(parsed.contents.clone()))
256 .into_any()
257}
258
259fn render_markdown_paragraph(parsed: &ParsedMarkdownText, cx: &mut RenderContext) -> AnyElement {
260 cx.with_common_p(div())
261 .child(render_markdown_text(parsed, cx))
262 .into_any_element()
263}
264
265fn render_markdown_text(parsed: &ParsedMarkdownText, cx: &mut RenderContext) -> AnyElement {
266 let element_id = cx.next_id(&parsed.source_range);
267
268 let highlights = gpui::combine_highlights(
269 parsed.highlights.iter().filter_map(|(range, highlight)| {
270 let highlight = highlight.to_highlight_style(&cx.syntax_theme)?;
271 Some((range.clone(), highlight))
272 }),
273 parsed
274 .regions
275 .iter()
276 .zip(&parsed.region_ranges)
277 .filter_map(|(region, range)| {
278 if region.code {
279 Some((
280 range.clone(),
281 HighlightStyle {
282 background_color: Some(cx.code_span_background_color),
283 ..Default::default()
284 },
285 ))
286 } else {
287 None
288 }
289 }),
290 );
291
292 let mut links = Vec::new();
293 let mut link_ranges = Vec::new();
294 for (range, region) in parsed.region_ranges.iter().zip(&parsed.regions) {
295 if let Some(link) = region.link.clone() {
296 links.push(link);
297 link_ranges.push(range.clone());
298 }
299 }
300
301 let workspace = cx.workspace.clone();
302
303 InteractiveText::new(
304 element_id,
305 StyledText::new(parsed.contents.clone()).with_highlights(&cx.text_style, highlights),
306 )
307 .on_click(
308 link_ranges,
309 move |clicked_range_ix, window_cx| match &links[clicked_range_ix] {
310 Link::Web { url } => window_cx.open_url(url),
311 Link::Path { path } => {
312 if let Some(workspace) = &workspace {
313 _ = workspace.update(window_cx, |workspace, cx| {
314 workspace.open_abs_path(path.clone(), false, cx).detach();
315 });
316 }
317 }
318 },
319 )
320 .into_any_element()
321}
322
323fn render_markdown_rule(cx: &mut RenderContext) -> AnyElement {
324 let rule = div().w_full().h(px(2.)).bg(cx.border_color);
325 div().pt_3().pb_3().child(rule).into_any()
326}