Files
signed/crates/ui/src/components/markdown.rs
T
reya 7962c2c50e
Rust / build (macos-latest, stable) (push) Waiting to run
Rust / build (ubuntu-latest, stable) (push) Waiting to run
Rust / build (windows-latest, stable) (push) Waiting to run
refactor(ui): use v_flex/h_flex helpers in components
2026-11-20 08:43:28 +07:00

2039 lines
67 KiB
Rust

//! Renders a markdown document as formatted, selectable text. Parsing runs
//! once per source change and produces [`MarkdownBlock`]s; rendering
//! virtualizes the visible blocks and resolves styles from the theme at
//! draw time. Text, code, and tables drag-select and copy; task checkboxes
//! report toggles and code blocks offer a copy action. Images render inline
//! or as standalone blocks. Footnotes, math, and HTML render nothing; long
//! code lines clip rather than scroll.
//!
//! The view is the state: build a [`MarkdownViewState`] in a
//! [`gpui::Entity`] and embed it with [`TextView::new`], or let
//! [`TextView::markdown`] own its state under an element id.
//!
//! # Examples
//!
//! ```no_run
//! use gpui::{App, AppContext as _};
//! use ui::markdown::{MarkdownViewState, TextView};
//!
//! fn notes(cx: &mut App) -> TextView {
//! let state = cx.new(|_| MarkdownViewState::new("notes", "# Notes\n- [x] shipped"));
//! TextView::new(&state)
//! .on_link_click(|destination, _window, _cx| println!("{destination}"))
//! .on_task_toggle(|index, checked, _window, _cx| println!("{index}: {checked}"))
//! }
//! ```
use std::borrow::Borrow as _;
use std::collections::HashMap;
use std::hash::{DefaultHasher, Hash, Hasher};
use std::ops::Range;
use std::rc::Rc;
use std::sync::Arc;
use gpui::prelude::FluentBuilder as _;
use gpui::{
AnyElement, App, Bounds, ClipboardItem, Context, Div, Element, ElementId, Entity, FontStyle,
FontWeight, GlobalElementId, HighlightStyle, InspectorElementId, InteractiveElement as _,
InteractiveText, IntoElement, KeyBinding, KeyBindingContextPredicate, LayoutId, ListAlignment,
ListOffset, ListState, MouseButton, MouseDownEvent, MouseMoveEvent, ObjectFit,
ParentElement as _, Pixels, Refineable as _, Rems, Render, SharedString,
StatefulInteractiveElement as _, StrikethroughStyle, StyleRefinement, Styled, StyledImage as _,
StyledText, TextLayout, UnderlineStyle, Window, actions, div, img, list, px, relative, rems,
};
use pulldown_cmark::{CodeBlockKind, Event, HeadingLevel, Options, Parser, Tag, TagEnd};
use crate::components::button::{Button, ButtonVariant};
use crate::components::checkbox::Checkbox;
use crate::components::common::{Sizable as _, StyledExt as _, h_flex, v_flex};
use crate::components::highlight::{HighlightedCode, Language, highlight, plain};
use crate::components::scrollbar::{Scrollbar, ScrollbarVisibility};
use crate::components::utils::code_line;
use crate::theme::{ActiveTheme as _, BORDER_WIDTH, CODE_LINE_HEIGHT, CODE_OVERSCROLL_MAX, Size};
/// The body line height.
const BODY_LINE_HEIGHT: f32 = 1.6;
/// The key context the text view declares while it holds focus.
pub const TEXT_VIEW_CONTEXT: &str = "TextView";
/// The callback a view invokes when the user clicks a markdown link.
pub type LinkClickHandler = Arc<dyn Fn(&SharedString, &mut Window, &mut App)>;
/// The callback a view invokes when the user toggles a task checkbox.
pub type TaskToggleHandler = Arc<dyn Fn(usize, bool, &mut Window, &mut App)>;
actions!(text_view, [Copy]);
/// A heading level, 1 to 6.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum MarkdownHeading {
H1,
H2,
H3,
H4,
H5,
H6,
}
impl MarkdownHeading {
/// The level as a number, 1 to 6.
pub fn level(self) -> usize {
match self {
MarkdownHeading::H1 => 1,
MarkdownHeading::H2 => 2,
MarkdownHeading::H3 => 3,
MarkdownHeading::H4 => 4,
MarkdownHeading::H5 => 5,
MarkdownHeading::H6 => 6,
}
}
}
/// The marker drawn before a list item.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ListMarker {
/// An unordered bullet.
Bullet,
/// An ordered item, carrying its number in the list.
Ordered(u64),
/// A task item, `true` when checked.
Task(bool),
}
/// One inline item of a paragraph or list item: styled text or an image.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum InlineItem {
Text(InlineSpan),
Image {
/// Where the image loads from.
source: SharedString,
/// The image's alt text.
alt: SharedString,
},
}
/// The inline style a text run carries.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum InlineStyle {
/// Plain body text.
Text,
/// Italic emphasis.
Emphasis,
/// Bold emphasis.
Strong,
/// Bold and italic together.
StrongEmphasis,
/// Struck-through text.
Strikethrough,
/// Inline code.
Code,
/// A link with its destination.
Link { destination: SharedString },
}
/// One rendered block of a markdown document.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum MarkdownBlock {
Heading {
level: MarkdownHeading,
spans: Vec<InlineSpan>,
/// How many lists the heading's content sits under.
indent: usize,
/// Whether a blockquote wraps the heading.
quote: bool,
},
Paragraph {
items: Vec<InlineItem>,
/// How many lists the paragraph's content sits under.
indent: usize,
/// Whether a blockquote wraps the paragraph.
quote: bool,
},
ListItem {
marker: ListMarker,
items: Vec<InlineItem>,
/// How many lists wrap this item's list, zero for the outermost.
indent: usize,
/// Whether a blockquote wraps the item.
quote: bool,
},
/// An image that stands alone in its paragraph.
Image {
source: SharedString,
alt: SharedString,
/// How many lists the block sits under.
indent: usize,
/// Whether a blockquote wraps the block.
quote: bool,
},
Code {
language: Option<SharedString>,
lines: HighlightedCode,
/// How many lists the block sits under.
indent: usize,
/// Whether a blockquote wraps the block.
quote: bool,
},
ThematicBreak {
indent: usize,
quote: bool,
},
Table {
table: MarkdownTable,
indent: usize,
quote: bool,
},
}
impl MarkdownBlock {
/// Hashes the block so element ids track content, not list position.
fn content_hash(&self) -> u64 {
let mut hasher = DefaultHasher::new();
self.hash(&mut hasher);
hasher.finish()
}
}
/// One run of inline text sharing a style.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct InlineSpan {
/// The run's text.
pub text: SharedString,
/// The style applied to the text.
pub style: InlineStyle,
}
/// One cell of a table row.
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct MarkdownTableCell {
pub spans: Vec<InlineSpan>,
}
/// A table row; the header row precedes the body rows.
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct MarkdownTableRow {
pub cells: Vec<MarkdownTableCell>,
pub header: bool,
}
/// A table, header row first.
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct MarkdownTable {
pub rows: Vec<MarkdownTableRow>,
}
/// Retained state for a markdown view.
///
/// Build one in a [`gpui::Entity`] and embed it with [`TextView::new`], or
/// let [`TextView::markdown`] own its state under an element id.
pub struct MarkdownViewState {
id: ElementId,
source: SharedString,
blocks: Vec<MarkdownBlock>,
block_ids: Vec<ElementId>,
/// Whether fenced code blocks highlight with the code view's palette.
highlight_code: bool,
/// Drives the vertical scroll of the virtualized block list.
handle: ListState,
a11y_label: Option<SharedString>,
link_handler: Option<LinkClickHandler>,
task_toggle_handler: Option<TaskToggleHandler>,
/// `(anchor, head)` in the order they were set, over the rendered text.
selection: Option<(usize, usize)>,
/// Whether a drag is still extending the selection.
selecting: bool,
focus_handle: Option<gpui::FocusHandle>,
}
impl MarkdownViewState {
/// Builds the state, parsing `source`.
pub fn new<I, S>(id: I, source: S) -> Self
where
I: Into<ElementId>,
S: Into<SharedString>,
{
let id = id.into();
let source = source.into();
let blocks = parse(&source, true);
let block_ids = Self::stable_block_ids(&id, &blocks);
let count = blocks.len();
Self {
id,
source,
blocks,
block_ids,
highlight_code: true,
handle: ListState::new(count, ListAlignment::Top, CODE_OVERSCROLL_MAX),
a11y_label: None,
link_handler: None,
task_toggle_handler: None,
selection: None,
selecting: false,
focus_handle: None,
}
}
/// Renders fenced code blocks without the code view's highlighting.
pub fn plain_code(mut self) -> Self {
self.highlight_code = false;
self.reparse();
self
}
/// Replaces the source and re-parses it; an equal source is a no-op.
pub fn set_source<S>(&mut self, source: S, cx: &mut Context<Self>)
where
S: Into<SharedString>,
{
let source = source.into();
if self.source == source {
return;
}
self.source = source;
self.reparse();
cx.notify();
}
fn reparse(&mut self) {
let blocks = parse(&self.source, self.highlight_code);
let block_ids = Self::stable_block_ids(&self.id, &blocks);
self.blocks = blocks;
self.block_ids = block_ids;
self.selection = None;
self.selecting = false;
self.handle.reset(self.blocks.len());
self.handle.scroll_to_reveal_item(0);
}
/// Ids built from the block's content hash plus an ordinal among blocks of equal content.
fn stable_block_ids(id: &ElementId, blocks: &[MarkdownBlock]) -> Vec<ElementId> {
let mut ids = Vec::with_capacity(blocks.len());
let mut occurrences = HashMap::with_capacity(blocks.len());
for block in blocks {
let hash = block.content_hash();
let occurrence = *occurrences
.entry(hash)
.and_modify(|count| *count += 1)
.or_insert(0);
ids.push(ElementId::from(SharedString::from(format!(
"{id}-block-{hash:x}-{occurrence}"
))));
}
ids
}
/// The markdown source the view renders.
pub fn source(&self) -> &str {
&self.source
}
/// The parsed blocks.
pub fn blocks(&self) -> &[MarkdownBlock] {
&self.blocks
}
/// The stable element id of the block at `block_index`.
pub fn block_id(&self, block_index: usize) -> Option<ElementId> {
self.block_ids.get(block_index).cloned()
}
/// Whether fenced code highlights with the code view's palette.
pub fn highlight_code(&self) -> bool {
self.highlight_code
}
/// Scrolls `block` to the top of the view.
pub fn scroll_to_block(&self, block: usize) {
let item_ix = block.min(self.blocks.len().saturating_sub(1));
self.handle.scroll_to(ListOffset {
item_ix,
offset_in_item: px(0.),
});
}
/// Overrides the accessibility label of the view.
pub fn accessibility_label<L>(mut self, label: L) -> Self
where
L: Into<SharedString>,
{
self.a11y_label = Some(label.into());
self
}
/// Invokes `handler` when the user clicks a link, instead of opening it.
pub fn on_link_click<F>(mut self, handler: F) -> Self
where
F: Fn(&SharedString, &mut Window, &mut App) + 'static,
{
self.link_handler = Some(Arc::new(handler));
self
}
/// Replaces the link click handler.
pub fn set_link_handler(&mut self, handler: LinkClickHandler) {
self.link_handler = Some(handler);
}
/// Invokes `handler(block, checked)` when the user toggles a task checkbox.
pub fn on_task_toggle<F>(mut self, handler: F) -> Self
where
F: Fn(usize, bool, &mut Window, &mut App) + 'static,
{
self.task_toggle_handler = Some(Arc::new(handler));
self
}
/// Replaces the task toggle handler.
pub fn set_task_toggle_handler(&mut self, handler: TaskToggleHandler) {
self.task_toggle_handler = Some(handler);
}
/// Selects a range over the rendered text, endpoints in byte offsets.
pub fn select_range(&mut self, start: usize, end: usize, cx: &mut Context<Self>) {
self.selection = Some((start, end));
self.selecting = false;
cx.notify();
}
/// The selected range over the rendered text, endpoints in document
/// order, when there is one.
pub fn selection(&self) -> Option<(usize, usize)> {
let (anchor, head) = self.selection?;
Some(if anchor <= head {
(anchor, head)
} else {
(head, anchor)
})
}
/// The selected text, or `None` when nothing is selected.
pub fn selected_text(&self) -> Option<String> {
let document = text_document(&self.blocks);
let (start, end) = self.selection()?;
let end = end.min(document.len);
let start = start.min(end);
Some(document.text(&self.blocks)[start..end].to_string()).filter(|text| !text.is_empty())
}
/// The focus handle the view claims on click, created on first use.
fn focus_handle(&mut self, cx: &mut App) -> gpui::FocusHandle {
self.focus_handle
.get_or_insert_with(|| cx.focus_handle().tab_stop(true))
.clone()
}
}
impl Render for MarkdownViewState {
fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
let id = self.id.clone();
let state = cx.entity();
let focus_handle = self.focus_handle(cx);
let frame = std::rc::Rc::new(ViewFrame {
state: state.clone(),
link_handler: self.link_handler.clone(),
task_toggle: self.task_toggle_handler.clone(),
selection: self.selection(),
focus_handle,
pressed_on_piece: std::rc::Rc::new(std::cell::Cell::new(false)),
});
let doc = std::rc::Rc::new(text_document(&self.blocks));
let blocks = list(self.handle.clone(), {
let frame = frame.clone();
let doc = doc.clone();
move |block_index, _window, cx| {
let view = state.read(cx);
match view
.blocks
.get(block_index)
.zip(view.block_ids.get(block_index))
{
Some((block, block_id)) => {
let ctx = BlockContext {
frame: &frame,
doc: &doc,
block_index,
block_id,
};
render_block(block, block_index, &ctx, cx)
}
None => div().into_any_element(),
}
}
})
.size_full();
view_container(&frame)
.id((id.clone(), "view"))
.relative()
.size_full()
.child(blocks)
.child(
Scrollbar::vertical((self.id.clone(), "v-scrollbar"), self.handle.clone())
.visibility(ScrollbarVisibility::Platform),
)
.when_some(self.a11y_label.clone(), |view, label| {
view.aria_label(label)
})
}
}
/// The per-frame context the view's renderers wire themselves from.
struct ViewFrame {
state: Entity<MarkdownViewState>,
link_handler: Option<LinkClickHandler>,
task_toggle: Option<TaskToggleHandler>,
/// The selection over the rendered text, endpoints in document order.
selection: Option<(usize, usize)>,
focus_handle: gpui::FocusHandle,
/// Set when a press landed on a piece.
pressed_on_piece: std::rc::Rc<std::cell::Cell<bool>>,
}
/// The per-block context, one per block as it renders.
struct BlockContext<'a> {
frame: &'a ViewFrame,
doc: &'a TextDocument,
block_index: usize,
block_id: &'a ElementId,
}
impl BlockContext<'_> {
/// The block's pieces, in render order.
fn pieces(&self) -> &[TextPiece] {
let start = self
.doc
.pieces
.partition_point(|piece| piece.block_index < self.block_index);
let count = self.doc.pieces[start..]
.iter()
.take_while(|piece| piece.block_index == self.block_index)
.count();
&self.doc.pieces[start..start + count]
}
/// The piece at `offset`.
fn piece_context(&self, offset: usize) -> Option<PieceContext> {
let piece = self.pieces().get(offset)?;
let selected = self.frame.selection.and_then(|(start, end)| {
let selected = start.max(piece.range.start)..end.min(piece.range.end);
(!selected.is_empty())
.then(|| (selected.start - piece.range.start)..(selected.end - piece.range.start))
});
Some(PieceContext {
state: self.frame.state.clone(),
link_handler: self.frame.link_handler.clone(),
doc_range: piece.range.clone(),
selected,
pressed_on_piece: self.frame.pressed_on_piece.clone(),
})
}
}
/// What one selectable text element wires itself from.
struct PieceContext {
state: Entity<MarkdownViewState>,
link_handler: Option<LinkClickHandler>,
/// The piece's byte range in the rendered text.
doc_range: Range<usize>,
/// The selection overlap, in piece-local bytes.
selected: Option<Range<usize>>,
pressed_on_piece: std::rc::Rc<std::cell::Cell<bool>>,
}
/// One selectable stretch of rendered text.
#[derive(Clone, Debug)]
pub struct TextPiece {
/// The block the piece belongs to.
pub block_index: usize,
/// Which selectable unit of its block this is, in render order.
pub sub_index: usize,
/// The piece's byte range in the view's rendered text.
pub range: Range<usize>,
}
/// The rendered text of a document: its selectable pieces and total length.
#[derive(Clone, Debug, Default)]
pub struct TextDocument {
/// The pieces, in document order.
pub pieces: Vec<TextPiece>,
/// The rendered text length in bytes.
pub len: usize,
}
impl TextDocument {
/// The rendered text, built on demand.
fn text(&self, blocks: &[MarkdownBlock]) -> String {
let mut out = String::with_capacity(self.len);
let mut piece_ix = 0;
for (block_index, block) in blocks.iter().enumerate() {
if piece_ix >= self.pieces.len() || self.pieces[piece_ix].block_index != block_index {
continue;
}
let block_end = self.pieces[piece_ix..]
.iter()
.position(|piece| piece.block_index != block_index)
.map_or(self.pieces.len(), |offset| piece_ix + offset);
let units = block_text_units(block);
for piece in &self.pieces[piece_ix..block_end] {
let Some(unit) = units.get(piece.sub_index).filter(|unit| !unit.is_empty()) else {
continue;
};
if !out.is_empty() {
out.push('\n');
}
out.push_str(unit);
}
piece_ix = block_end;
}
out
}
}
/// An embeddable markdown text view: fit-content height, no scrolling.
pub struct TextView {
id: ElementId,
source: Option<SharedString>,
state: Option<Entity<MarkdownViewState>>,
link_handler: Option<LinkClickHandler>,
task_toggle_handler: Option<TaskToggleHandler>,
style: StyleRefinement,
}
impl TextView {
/// Renders `source`, keeping its parsed state across frames under `id`.
pub fn markdown<I, S>(id: I, source: S) -> Self
where
I: Into<ElementId>,
S: Into<SharedString>,
{
Self {
id: id.into(),
source: Some(source.into()),
state: None,
link_handler: None,
task_toggle_handler: None,
style: StyleRefinement::default(),
}
}
/// Wraps an owned state; its source drives what the view renders.
pub fn new(state: &Entity<MarkdownViewState>) -> Self {
Self {
id: ElementId::from(SharedString::from(format!("{}", state.entity_id()))),
source: None,
state: Some(state.clone()),
link_handler: None,
task_toggle_handler: None,
style: StyleRefinement::default(),
}
}
/// Invokes `handler` when the user clicks a link, instead of opening it.
pub fn on_link_click<F>(mut self, handler: F) -> Self
where
F: Fn(&SharedString, &mut Window, &mut App) + 'static,
{
self.link_handler = Some(Arc::new(handler));
self
}
/// Invokes `handler(block, checked)` when the user toggles a task checkbox.
pub fn on_task_toggle<F>(mut self, handler: F) -> Self
where
F: Fn(usize, bool, &mut Window, &mut App) + 'static,
{
self.task_toggle_handler = Some(Arc::new(handler));
self
}
}
impl Styled for TextView {
fn style(&mut self) -> &mut StyleRefinement {
&mut self.style
}
}
impl Element for TextView {
type PrepaintState = ();
type RequestLayoutState = AnyElement;
fn id(&self) -> Option<ElementId> {
Some(self.id.clone())
}
fn source_location(&self) -> Option<&'static std::panic::Location<'static>> {
None
}
fn request_layout(
&mut self,
_id: Option<&GlobalElementId>,
_inspector_id: Option<&InspectorElementId>,
window: &mut Window,
cx: &mut App,
) -> (LayoutId, Self::RequestLayoutState) {
let state = match self.state.clone() {
Some(state) => state,
None => {
let view_id = self.id.clone();
let source = self.source.clone().unwrap_or_default();
let state_key = SharedString::from(format!("{}/state", self.id));
window.use_keyed_state(state_key, cx, move |_, _| {
MarkdownViewState::new(view_id, source)
})
}
};
let source = self.source.clone();
let link_handler = self.link_handler.clone();
let task_toggle = self.task_toggle_handler.clone();
let (selection, focus_handle) =
state.update(cx, |view, cx| (view.selection(), view.focus_handle(cx)));
state.update(cx, |view, cx| {
if let Some(source) = source {
view.set_source(source, cx);
}
if let Some(link_handler) = link_handler {
view.set_link_handler(link_handler);
}
if let Some(task_toggle) = task_toggle {
view.set_task_toggle_handler(task_toggle);
}
});
let view = state.read(cx);
let frame = ViewFrame {
state: state.clone(),
link_handler: view.link_handler.clone(),
task_toggle: view.task_toggle_handler.clone(),
selection,
focus_handle,
pressed_on_piece: std::rc::Rc::new(std::cell::Cell::new(false)),
};
let doc = text_document(&view.blocks);
let mut element = render_blocks(&view.blocks, &frame, &doc, &view.block_ids, cx);
element.style().refine(&self.style);
let mut element = element.into_any_element();
let layout_id = element.request_layout(window, cx);
(layout_id, element)
}
fn prepaint(
&mut self,
_id: Option<&GlobalElementId>,
_inspector_id: Option<&InspectorElementId>,
_bounds: Bounds<Pixels>,
request_layout: &mut Self::RequestLayoutState,
window: &mut Window,
cx: &mut App,
) {
request_layout.prepaint(window, cx);
}
fn paint(
&mut self,
_id: Option<&GlobalElementId>,
_inspector_id: Option<&InspectorElementId>,
_bounds: Bounds<Pixels>,
request_layout: &mut Self::RequestLayoutState,
_prepaint: &mut Self::PrepaintState,
window: &mut Window,
cx: &mut App,
) {
request_layout.paint(window, cx);
}
}
/// One open list, tracking ordered numbering and an in-flight task marker.
struct ListFrame {
ordered: bool,
next_number: u64,
task: Option<bool>,
}
/// Accumulates inline spans across inline events.
#[derive(Default)]
struct InlineBuilder {
runs: Vec<(String, InlineStyle)>,
styles: Vec<Option<InlineStyle>>,
}
impl InlineBuilder {
fn push_style(&mut self, style: Option<InlineStyle>) {
self.styles.push(style);
}
fn pop_style(&mut self) {
self.styles.pop();
}
fn active(&self) -> InlineStyle {
let mut strong = false;
let mut emphasis = false;
for style in self.styles.iter().rev().flatten() {
match style {
InlineStyle::Strong if emphasis => return InlineStyle::StrongEmphasis,
InlineStyle::Strong => strong = true,
InlineStyle::Emphasis if strong => return InlineStyle::StrongEmphasis,
InlineStyle::Emphasis => emphasis = true,
other => return other.clone(),
}
}
match (strong, emphasis) {
(true, true) => InlineStyle::StrongEmphasis,
(true, false) => InlineStyle::Strong,
(false, true) => InlineStyle::Emphasis,
(false, false) => InlineStyle::Text,
}
}
fn push_text(&mut self, text: &str) {
if text.is_empty() {
return;
}
let style = self.active();
if let Some((run, run_style)) = self.runs.last_mut()
&& *run_style == style
{
run.push_str(text);
return;
}
self.runs.push((text.to_string(), style));
}
/// Emits one span per contiguous style run.
fn finish(&mut self) -> Vec<InlineSpan> {
self.runs
.drain(..)
.map(|(text, style)| InlineSpan {
text: SharedString::from(text),
style,
})
.collect()
}
}
/// Binds the text view's copy chord: cmd-c on macOS, ctrl-c elsewhere.
///
/// Call once at startup. Without it, selection copy has no key.
pub fn bind_text_view_keys(cx: &mut App) {
let context = match KeyBindingContextPredicate::parse(TEXT_VIEW_CONTEXT) {
Ok(context) => Some(Rc::new(context)),
Err(error) => {
log::error!("failed to parse text view key context: {error}");
return;
}
};
let binding = match KeyBinding::load("secondary-c", Box::new(Copy), context, false, None, cx) {
Ok(binding) => binding,
Err(error) => {
log::error!("failed to parse text view copy keystroke: {error}");
return;
}
};
cx.bind_keys([binding]);
}
/// The view's base container: selection wiring, focus, and copy.
fn view_container(frame: &ViewFrame) -> Div {
let clear_flag = frame.pressed_on_piece.clone();
v_flex()
.w_full()
.key_context(TEXT_VIEW_CONTEXT)
.track_focus(&frame.focus_handle)
.on_action({
let state = frame.state.clone();
move |_: &Copy, _window, cx| {
if let Some(text) = state.read(cx).selected_text() {
cx.write_to_clipboard(ClipboardItem::new_string(text));
}
}
})
.on_mouse_down(MouseButton::Left, {
let state = frame.state.clone();
move |_, window, cx| {
let focus_handle = state.update(cx, |view, cx| view.focus_handle(cx));
window.focus(&focus_handle, cx);
if !clear_flag.replace(false) {
state.update(cx, |view, cx| {
if view.selection.take().is_some() {
cx.notify();
}
});
}
}
})
.on_mouse_up(MouseButton::Left, {
let state = frame.state.clone();
move |_, _, cx| {
if state.read(cx).selecting {
state.update(cx, |view, cx| {
view.selecting = false;
cx.notify();
});
}
}
})
}
/// Renders every block stacked, without virtualization or scrolling.
fn render_blocks(
blocks: &[MarkdownBlock],
frame: &ViewFrame,
doc: &TextDocument,
block_ids: &[ElementId],
cx: &App,
) -> Div {
view_container(frame).children(blocks.iter().zip(block_ids).enumerate().map(
|(block_index, (block, block_id))| {
let ctx = BlockContext {
frame,
doc,
block_index,
block_id,
};
render_block(block, block_index, &ctx, cx)
},
))
}
fn spans_text_of(spans: &[InlineSpan]) -> String {
spans.iter().map(|span| span.text.as_ref()).collect()
}
/// The selectable text units of a block.
fn block_text_units(block: &MarkdownBlock) -> Vec<String> {
match block {
MarkdownBlock::Heading { spans, .. } => vec![spans_text_of(spans)],
MarkdownBlock::Paragraph { items, .. } | MarkdownBlock::ListItem { items, .. } => {
let mut units: Vec<String> = Vec::new();
for item in items {
match item {
InlineItem::Text(span) => match units.last_mut() {
// Consecutive text items share the unit between images.
Some(unit) => unit.push_str(&span.text),
None => units.push(span.text.as_ref().to_string()),
},
// An image starts the next unit; the render emits no
// element for it.
InlineItem::Image { .. } => units.push(String::new()),
}
}
units
}
MarkdownBlock::Code { lines, .. } => lines.lines.iter().map(|line| line.text()).collect(),
MarkdownBlock::Table { table, .. } => table
.rows
.iter()
.flat_map(|row| row.cells.iter())
.map(|cell| spans_text_of(&cell.spans))
.collect(),
MarkdownBlock::Image { .. } | MarkdownBlock::ThematicBreak { .. } => Vec::new(),
}
}
/// Enumerates the selectable text pieces of `blocks`, in render order.
fn text_document(blocks: &[MarkdownBlock]) -> TextDocument {
let mut pieces = Vec::new();
let mut len = 0usize;
for (block_index, block) in blocks.iter().enumerate() {
// Paragraphs render no element for an empty unit.
let skip_empty = matches!(
block,
MarkdownBlock::Paragraph { .. } | MarkdownBlock::ListItem { .. }
);
for (sub_index, unit) in block_text_units(block).into_iter().enumerate() {
if unit.is_empty() && skip_empty {
continue;
}
let mut range = len..len;
if !unit.is_empty() {
if len > 0 {
len += 1; // The newline that joins pieces.
}
range = len..len + unit.len();
len = range.end;
}
pieces.push(TextPiece {
block_index,
sub_index,
range,
});
}
}
TextDocument { pieces, len }
}
/// The markdown extensions the view parses, on top of CommonMark.
fn options() -> Options {
let mut options = Options::empty();
options.insert(Options::ENABLE_TABLES);
options.insert(Options::ENABLE_STRIKETHROUGH);
options.insert(Options::ENABLE_TASKLISTS);
options
}
fn heading(level: HeadingLevel) -> MarkdownHeading {
match level {
HeadingLevel::H1 => MarkdownHeading::H1,
HeadingLevel::H2 => MarkdownHeading::H2,
HeadingLevel::H3 => MarkdownHeading::H3,
HeadingLevel::H4 => MarkdownHeading::H4,
HeadingLevel::H5 => MarkdownHeading::H5,
HeadingLevel::H6 => MarkdownHeading::H6,
}
}
/// Parses `source` into blocks.
fn parse(source: &str, highlight_code: bool) -> Vec<MarkdownBlock> {
let mut blocks = Vec::new();
let mut inline = InlineBuilder::default();
let mut inline_items: Vec<InlineItem> = Vec::new();
let mut lists: Vec<ListFrame> = Vec::new();
// Whether each open list item already flushed content rows.
let mut items: Vec<bool> = Vec::new();
let mut quote_depth = 0usize;
let mut table: Option<Vec<MarkdownTableRow>> = None;
let mut code: Option<String> = None;
// The fence info string arrives on Start, its text follows.
let mut code_language: Option<SharedString> = None;
// The image being parsed: its source and its alt text so far.
let mut image: Option<(SharedString, String)> = None;
for event in Parser::new_ext(source, options()) {
match event {
Event::Start(tag) => match tag {
Tag::Paragraph | Tag::TableCell | Tag::Item => {
inline = InlineBuilder::default();
inline_items = Vec::new();
if matches!(tag, Tag::Item) {
// The marker is only in flight while its own item is open.
if let Some(frame) = lists.last_mut() {
frame.task = None;
}
items.push(false);
}
}
Tag::Heading { level, .. } => {
flush_item_inline(
&mut inline,
&mut inline_items,
&mut items,
&mut lists,
&mut blocks,
quote_depth,
);
inline = InlineBuilder::default();
inline_items = Vec::new();
blocks.push(MarkdownBlock::Heading {
level: heading(level),
spans: Vec::new(),
indent: lists.len(),
quote: quote_depth > 0,
});
}
Tag::BlockQuote(_) => {
flush_item_inline(
&mut inline,
&mut inline_items,
&mut items,
&mut lists,
&mut blocks,
quote_depth,
);
quote_depth += 1;
}
Tag::List(start) => {
flush_item_inline(
&mut inline,
&mut inline_items,
&mut items,
&mut lists,
&mut blocks,
quote_depth,
);
lists.push(ListFrame {
ordered: start.is_some(),
next_number: start.unwrap_or_default(),
task: None,
});
}
Tag::CodeBlock(kind) => {
flush_item_inline(
&mut inline,
&mut inline_items,
&mut items,
&mut lists,
&mut blocks,
quote_depth,
);
code = Some(String::new());
if let CodeBlockKind::Fenced(info) = kind {
let info = info.trim();
code_language =
(!info.is_empty()).then(|| SharedString::from(info.to_string()));
}
}
Tag::Table(_) => {
flush_item_inline(
&mut inline,
&mut inline_items,
&mut items,
&mut lists,
&mut blocks,
quote_depth,
);
table = Some(Vec::new())
}
Tag::TableHead => {
if let Some(rows) = &mut table {
rows.push(MarkdownTableRow {
cells: Vec::new(),
header: true,
});
}
}
Tag::TableRow => {
if let Some(rows) = &mut table {
rows.push(MarkdownTableRow {
cells: Vec::new(),
header: false,
});
}
}
Tag::Emphasis | Tag::Strong | Tag::Strikethrough => {
let style = match tag {
Tag::Emphasis => InlineStyle::Emphasis,
Tag::Strong => InlineStyle::Strong,
_ => InlineStyle::Strikethrough,
};
inline.push_style(Some(style));
}
Tag::Link { dest_url, .. } => inline.push_style(Some(InlineStyle::Link {
destination: SharedString::from(dest_url.to_string()),
})),
Tag::Image { dest_url, .. } => {
image = Some((SharedString::from(dest_url.to_string()), String::new()))
}
Tag::HtmlBlock | Tag::MetadataBlock(_) => {}
_ => {}
},
Event::End(tag_end) => match tag_end {
TagEnd::Paragraph => {
let mut paragraph_items = std::mem::take(&mut inline_items);
for span in inline.finish() {
paragraph_items.push(InlineItem::Text(span));
}
let quote = quote_depth > 0;
match items.last_mut() {
// The item's first paragraph carries its marker row.
Some(flushed @ false) => {
*flushed = true;
blocks.push(MarkdownBlock::ListItem {
marker: take_marker(&mut lists),
items: paragraph_items,
indent: lists.len().saturating_sub(1),
quote,
});
}
_ => {
if let Some(item) = items.last_mut() {
*item = true;
}
push_paragraph_items(paragraph_items, lists.len(), quote, &mut blocks);
}
}
}
TagEnd::Heading(_) => {
let spans = inline.finish();
if let Some(MarkdownBlock::Heading { spans: slots, .. }) = blocks.last_mut() {
*slots = spans;
}
}
TagEnd::BlockQuote(_) => quote_depth = quote_depth.saturating_sub(1),
TagEnd::List(_) => {
lists.pop();
}
TagEnd::Item => {
let flushed = items.pop().unwrap_or(false);
let mut block_items = std::mem::take(&mut inline_items);
for span in inline.finish() {
block_items.push(InlineItem::Text(span));
}
if block_items.is_empty() && flushed {
continue;
}
let indent = lists.len();
let quote = quote_depth > 0;
if flushed {
push_paragraph_items(block_items, indent, quote, &mut blocks);
} else {
blocks.push(MarkdownBlock::ListItem {
marker: take_marker(&mut lists),
items: block_items,
indent: indent.saturating_sub(1),
quote,
});
}
}
TagEnd::CodeBlock => {
let built = code.take().unwrap_or_default();
let text = built.trim_end_matches('\n');
let language = code_language.take();
let lines = match highlight_code
.then(|| language.as_deref().and_then(Language::from_fence_info))
.flatten()
{
Some(grammar) => highlight(text, grammar),
None => plain(text),
};
blocks.push(MarkdownBlock::Code {
language,
lines,
indent: lists.len(),
quote: quote_depth > 0,
});
}
TagEnd::Table => {
if let Some(rows) = table.take() {
blocks.push(MarkdownBlock::Table {
table: MarkdownTable { rows },
indent: lists.len(),
quote: quote_depth > 0,
});
}
}
TagEnd::TableCell => {
let spans = inline.finish();
let Some(rows) = &mut table else {
continue;
};
let Some(row) = rows.last_mut() else {
continue;
};
row.cells.push(MarkdownTableCell { spans });
}
TagEnd::Image => {
if let Some((source, alt)) = image.take() {
let in_cell = table.is_some();
let in_heading = matches!(
blocks.last(),
Some(MarkdownBlock::Heading { spans, .. }) if spans.is_empty()
);
if in_cell || in_heading {
// Headings and table cells keep images as alt text.
inline.push_text(&alt);
} else {
for span in inline.finish() {
inline_items.push(InlineItem::Text(span));
}
inline_items.push(InlineItem::Image {
source,
alt: SharedString::from(alt),
});
}
}
}
TagEnd::Emphasis | TagEnd::Strong | TagEnd::Strikethrough | TagEnd::Link => {
inline.pop_style()
}
_ => {}
},
Event::Text(text) => {
if let Some(buffer) = code.as_mut() {
buffer.push_str(&text);
} else if let Some((_, alt)) = &mut image {
alt.push_str(&text);
} else {
inline.push_text(&text);
}
}
Event::Code(text) => {
if let Some((_, alt)) = &mut image {
alt.push_str(&text);
} else {
inline.push_style(Some(InlineStyle::Code));
inline.push_text(&text);
inline.pop_style();
}
}
Event::SoftBreak | Event::HardBreak => {
if let Some((_, alt)) = &mut image {
alt.push(' ');
} else {
inline.push_text(" ");
}
}
Event::Rule => {
flush_item_inline(
&mut inline,
&mut inline_items,
&mut items,
&mut lists,
&mut blocks,
quote_depth,
);
blocks.push(MarkdownBlock::ThematicBreak {
indent: lists.len(),
quote: quote_depth > 0,
});
}
Event::TaskListMarker(checked) => {
if let Some(frame) = lists.last_mut() {
frame.task = Some(checked);
}
}
// Footnotes are disabled in the parser options.
Event::FootnoteReference(_)
| Event::InlineHtml(_)
| Event::Html(_)
| Event::InlineMath(_)
| Event::DisplayMath(_) => {}
}
}
blocks
}
/// Computes the current item's marker and advances ordered numbering.
fn take_marker(lists: &mut [ListFrame]) -> ListMarker {
let Some(frame) = lists.last_mut() else {
return ListMarker::Bullet;
};
let marker = match frame.task {
Some(checked) => ListMarker::Task(checked),
None if frame.ordered => ListMarker::Ordered(frame.next_number),
None => ListMarker::Bullet,
};
if frame.ordered {
frame.next_number += 1;
}
marker
}
/// Pushes `items` as standalone image blocks when they hold nothing but images.
fn push_paragraph_items(
items: Vec<InlineItem>,
indent: usize,
quote: bool,
blocks: &mut Vec<MarkdownBlock>,
) {
let blank = |item: &InlineItem| match item {
InlineItem::Image { .. } => true,
InlineItem::Text(span) => span.text.chars().all(char::is_whitespace),
};
let image_only = !items.is_empty()
&& items
.iter()
.any(|item| matches!(item, InlineItem::Image { .. }))
&& items.iter().all(blank);
if image_only {
for item in items {
if let InlineItem::Image { source, alt } = item {
blocks.push(MarkdownBlock::Image {
source,
alt,
indent,
quote,
});
}
}
} else {
blocks.push(MarkdownBlock::Paragraph {
items,
indent,
quote,
});
}
}
/// Flushes an open tight item's inline text as its marker row.
fn flush_item_inline(
inline: &mut InlineBuilder,
inline_items: &mut Vec<InlineItem>,
items: &mut [bool],
lists: &mut [ListFrame],
blocks: &mut Vec<MarkdownBlock>,
quote_depth: usize,
) {
let Some(item) = items.last_mut() else {
return;
};
let mut block_items = std::mem::take(inline_items);
for span in inline.finish() {
block_items.push(InlineItem::Text(span));
}
if block_items.is_empty() {
return;
}
*item = true;
blocks.push(MarkdownBlock::ListItem {
marker: take_marker(lists),
items: block_items,
indent: lists.len().saturating_sub(1),
quote: quote_depth > 0,
});
}
/// Renders one parsed block as a list row.
fn render_block(
block: &MarkdownBlock,
block_index: usize,
ctx: &BlockContext,
cx: &App,
) -> AnyElement {
let gap = rems(0.75);
match block {
MarkdownBlock::Heading {
level,
spans,
indent,
quote,
} => heading_row(
*level,
spans,
*indent,
*quote,
if block_index == 0 {
Rems::ZERO
} else {
rems(0.375)
},
ctx,
cx,
),
MarkdownBlock::Paragraph {
items,
indent,
quote,
} => text_row(items, *indent, *quote, gap, None, ctx, cx),
MarkdownBlock::ListItem {
marker,
items,
indent,
quote,
} => text_row(items, *indent, *quote, rems(0.2), Some(*marker), ctx, cx),
MarkdownBlock::Image {
source,
alt,
indent,
quote,
} => image_row(source, alt, *indent, *quote, ctx, cx),
MarkdownBlock::Code {
language,
lines,
indent,
quote,
} => code_row(lines, language.as_ref(), *indent, *quote, ctx, cx),
MarkdownBlock::ThematicBreak { indent, quote } => rule_row(*indent, *quote, ctx, cx),
MarkdownBlock::Table {
table,
indent,
quote,
} => table_row(table, *indent, *quote, ctx, cx),
}
}
/// The shared block frame: ambient text style, spacing, quote bar.
fn block_frame(quote: bool, top: Rems, bottom: Rems, id: &ElementId, cx: &App) -> Div {
let theme = cx.theme();
v_flex()
.debug_selector({
let id = id.clone();
move || id.to_string()
})
.w_full()
.font_family(theme.ui_font())
.text_xs()
.line_height(relative(BODY_LINE_HEIGHT))
.text_color(theme.colors.foreground)
.pt(top)
.pb(bottom)
.when(quote, |frame| {
frame
.border_l_2()
.border_color(theme.colors.border)
.pl(rems(1.0))
})
}
/// Wraps the finished block in the list indent.
fn indented_frame(indent: usize, frame: Div) -> Div {
let indent = rems(1.5 * indent as f32);
if indent.0 > 0.0 {
div().w_full().pl(indent).child(frame)
} else {
frame
}
}
#[allow(clippy::too_many_arguments)]
fn heading_row(
level: MarkdownHeading,
spans: &[InlineSpan],
indent: usize,
quote: bool,
top: Rems,
ctx: &BlockContext,
cx: &App,
) -> AnyElement {
let frame = block_frame(quote, top, rems(0.75), ctx.block_id, cx);
let frame = match level {
MarkdownHeading::H1 => frame.text_xl().font_semibold(),
MarkdownHeading::H2 => frame.text_lg().font_semibold(),
MarkdownHeading::H3 => frame.text_base().font_semibold(),
MarkdownHeading::H4 | MarkdownHeading::H5 | MarkdownHeading::H6 => {
frame.text_sm().font_semibold()
}
};
indented_frame(
indent,
frame.child(text_child(spans, ctx.block_id, ctx.piece_context(0), cx)),
)
.into_any_element()
}
fn text_row(
items: &[InlineItem],
indent: usize,
quote: bool,
bottom: Rems,
marker: Option<ListMarker>,
ctx: &BlockContext,
cx: &App,
) -> AnyElement {
let theme = cx.theme();
indented_frame(
indent,
block_frame(quote, Rems::ZERO, bottom, ctx.block_id, cx).map(|frame| match marker {
Some(marker) => {
let line_height = rems(1.2);
let marker_cell = div()
.flex_none()
.w(rems(1.75))
.h(line_height)
.flex()
.items_center()
.justify_end()
.pr_1()
.child(match marker {
ListMarker::Bullet => div()
.size_1()
.rounded(theme.radius.full)
.bg(theme.colors.muted_foreground)
.into_any_element(),
ListMarker::Ordered(number) => div()
.text_color(theme.colors.muted_foreground)
.whitespace_nowrap()
.child(format!("{number}."))
.into_any_element(),
ListMarker::Task(checked) => task_toggle(checked, item_text(items), ctx),
});
frame.child(
div().flex().items_start().child(marker_cell).child(
div()
.flex_1()
.min_w_0()
.child(paragraph_child(items, ctx, cx)),
),
)
}
None => frame.child(paragraph_child(items, ctx, cx)),
}),
)
.into_any_element()
}
/// The task marker: a checkbox that reports toggles when a handler is set.
fn task_toggle(checked: bool, label: SharedString, ctx: &BlockContext) -> AnyElement {
let block_index = ctx.block_index;
let selector = SharedString::from(format!("task-toggle-{block_index}"));
let checkbox = Checkbox::new((ctx.block_id.clone(), "task"))
.debug_selector(move || selector.to_string())
.checked(checked)
.with_size(Size::Small)
.accessibility_label(label);
match ctx.frame.task_toggle.clone() {
Some(handler) => checkbox
.on_change(move |next, window, cx| handler(block_index, next, window, cx))
.into_any_element(),
None => checkbox.disabled(true).into_any_element(),
}
}
/// The item's plain text, for the checkbox's accessibility label.
fn item_text(items: &[InlineItem]) -> SharedString {
let text = items
.iter()
.filter_map(|item| match item {
InlineItem::Text(span) => Some(span.text.as_ref()),
InlineItem::Image { .. } => None,
})
.collect::<Vec<_>>()
.join("");
SharedString::from(text)
}
/// Builds a paragraph's content.
fn paragraph_child(items: &[InlineItem], ctx: &BlockContext, cx: &App) -> AnyElement {
let has_image = items
.iter()
.any(|item| matches!(item, InlineItem::Image { .. }));
if !has_image {
let spans = items.iter().filter_map(|item| match item {
InlineItem::Text(span) => Some(span),
InlineItem::Image { .. } => None,
});
return text_child(spans, ctx.block_id, ctx.piece_context(0), cx);
}
let side = rems(0.8625);
let mut flow = div().flex().flex_wrap().items_center();
let mut segment: Vec<&InlineSpan> = Vec::new();
let mut segment_index = 0;
for item in items {
match item {
InlineItem::Text(span) => segment.push(span),
InlineItem::Image { source, .. } => {
if !segment.is_empty() {
flow = flow.child(text_child(
segment,
&text_segment_id(ctx.block_id, segment_index),
ctx.piece_context(segment_index),
cx,
));
segment = Vec::new();
segment_index += 1;
}
flow = flow.child(
img(source.clone())
.size(side)
.object_fit(ObjectFit::ScaleDown)
.flex_none(),
);
}
}
}
if !segment.is_empty() {
flow = flow.child(text_child(
segment,
&text_segment_id(ctx.block_id, segment_index),
ctx.piece_context(segment_index),
cx,
));
}
flow.into_any_element()
}
/// A standalone image block, capped in height.
fn image_row(
source: &SharedString,
alt: &SharedString,
indent: usize,
quote: bool,
ctx: &BlockContext,
cx: &App,
) -> AnyElement {
let theme = cx.theme();
indented_frame(
indent,
block_frame(quote, Rems::ZERO, rems(0.75), ctx.block_id, cx).child(
img(source.clone())
.max_h(rems(14.0))
.max_w_full()
.rounded(theme.radius.control)
.overflow_hidden(),
),
)
.id((ctx.block_id.clone(), "image"))
.when(!alt.is_empty(), |frame| frame.aria_label(alt.clone()))
.into_any_element()
}
/// The element id of one text segment of a paragraph with images.
fn text_segment_id(id: &ElementId, segment_index: usize) -> ElementId {
ElementId::from(SharedString::from(format!("{id}-text-{segment_index}")))
}
fn code_row(
lines: &HighlightedCode,
language: Option<&SharedString>,
indent: usize,
quote: bool,
ctx: &BlockContext,
cx: &App,
) -> AnyElement {
let theme = cx.theme();
let text_size = rems(0.75).to_pixels(theme.root_font_size);
let line_height = text_size * CODE_LINE_HEIGHT;
let plain = lines
.lines
.iter()
.map(|line| line.text())
.collect::<Vec<_>>()
.join("\n");
let actions_row = h_flex()
.justify_between()
.pb_1()
.when_some(language.cloned(), |row, language| {
row.child(
div()
.text_xs()
.text_color(theme.colors.muted_foreground)
.child(language),
)
})
.child(
Button::new((ctx.block_id.clone(), "copy-code"))
.label("Copy")
.variant(ButtonVariant::Ghost)
.debug_selector(|| "copy-code".to_string())
.on_click(move |_, _, cx| {
cx.write_to_clipboard(ClipboardItem::new_string(plain.clone()));
}),
);
let plate = v_flex()
.w_full()
.rounded(theme.radius.control)
.bg(theme.colors.muted)
.p_2()
.font_family(theme.mono_font)
.text_xs()
.line_height(relative(CODE_LINE_HEIGHT))
.overflow_hidden()
.child(actions_row)
.children(lines.lines.iter().enumerate().map(|(line_ix, line)| {
let styled = code_line(line, theme.colors, theme.ramps);
let layout = styled.layout().clone();
with_selection_handlers(
div()
.h(line_height)
.whitespace_nowrap()
.overflow_hidden()
.child(styled),
ctx.piece_context(line_ix),
layout,
)
}));
indented_frame(
indent,
block_frame(quote, Rems::ZERO, rems(0.75), ctx.block_id, cx).child(plate),
)
.into_any_element()
}
fn rule_row(indent: usize, quote: bool, ctx: &BlockContext, cx: &App) -> AnyElement {
let theme = cx.theme();
indented_frame(
indent,
block_frame(quote, Rems::ZERO, rems(0.75), ctx.block_id, cx)
.child(div().h_px().w_full().bg(theme.colors.border)),
)
.into_any_element()
}
fn table_row(
table: &MarkdownTable,
indent: usize,
quote: bool,
ctx: &BlockContext,
cx: &App,
) -> AnyElement {
let theme = cx.theme();
let colors = theme.colors;
let width = table
.rows
.iter()
.map(|row| row.cells.len())
.max()
.unwrap_or(0);
let row_count = table.rows.len();
let mut cell_ix = 0usize;
let grid = v_flex()
.w_full()
.border_1()
.border_color(colors.border)
.rounded(theme.radius.control)
.overflow_hidden()
.children(table.rows.iter().enumerate().map(|(row_index, row)| {
div()
.w_full()
.flex()
.when(row_index + 1 < row_count, |row_element| {
row_element.border_b_1().border_color(colors.border)
})
.when(row.header, |row_element| row_element.bg(colors.muted))
.children(
row.cells
.iter()
.enumerate()
.map(|(column_index, cell)| {
let cell_id = ElementId::from(SharedString::from(format!(
"{}-cell-{row_index}-{column_index}",
ctx.block_id
)));
let piece = ctx.piece_context(cell_ix);
cell_ix += 1;
div()
.flex_1()
.min_w_0()
.px_2()
.py_1()
.when(row.header, |cell_element| cell_element.font_semibold())
.child(text_child(&cell.spans, &cell_id, piece, cx))
})
// Ragged tables pad missing cells so rows align.
.chain(
(row.cells.len()..width)
.map(|_| div().flex_1().min_w_0().px_2().py_1()),
),
)
}));
indented_frame(
indent,
block_frame(quote, Rems::ZERO, rems(0.75), ctx.block_id, cx).child(grid),
)
.into_any_element()
}
/// Attaches drag-selection handlers to `element` when it renders a piece.
fn with_selection_handlers(element: Div, piece: Option<PieceContext>, layout: TextLayout) -> Div {
let Some(piece) = piece else {
return element;
};
let state = piece.state.clone();
let doc_range = piece.doc_range.clone();
let pressed_on_piece = piece.pressed_on_piece.clone();
let layout_for_move = layout.clone();
element
.on_mouse_down(
MouseButton::Left,
move |event: &MouseDownEvent, window: &mut Window, cx: &mut App| {
pressed_on_piece.set(true);
let focus_handle = state.update(cx, |view, cx| view.focus_handle(cx));
window.focus(&focus_handle, cx);
let local = match layout.index_for_position(event.position) {
Ok(index) | Err(index) => index,
};
let index = doc_range.start + local;
state.update(cx, |view, cx| {
if event.modifiers.shift {
if let Some((anchor, _)) = view.selection {
view.selection = Some((anchor, index));
} else {
view.selection = Some((index, index));
}
} else {
view.selection = Some((index, index));
}
view.selecting = true;
cx.notify();
});
},
)
.on_mouse_move({
let state = piece.state.clone();
let doc_range = piece.doc_range.clone();
let layout = layout_for_move;
move |event: &MouseMoveEvent, _window: &mut Window, cx: &mut App| {
if !state.read(cx).selecting {
return;
}
let local = match layout.index_for_position(event.position) {
Ok(index) | Err(index) => index,
};
let index = doc_range.start + local;
let changed = state
.read(cx)
.selection
.map(|(_, head)| head != index)
.unwrap_or(true);
if changed {
state.update(cx, |view, cx| {
if let Some((anchor, _)) = view.selection {
view.selection = Some((anchor, index));
cx.notify();
}
});
}
}
})
.on_mouse_up(MouseButton::Left, {
let state = piece.state.clone();
move |_, _, cx| {
if state.read(cx).selecting {
state.update(cx, |view, cx| {
view.selecting = false;
cx.notify();
});
}
}
})
}
/// Builds the block's text element, selectable when it renders a piece.
fn text_child<I>(spans: I, id: &ElementId, piece: Option<PieceContext>, cx: &App) -> AnyElement
where
I: IntoIterator,
I::Item: std::borrow::Borrow<InlineSpan>,
{
let theme = cx.theme();
let mut text = String::new();
let mut highlights: Vec<(Range<usize>, HighlightStyle)> = Vec::new();
let mut family_overrides: Vec<(Range<usize>, SharedString)> = Vec::new();
let mut link_ranges: Vec<Range<usize>> = Vec::new();
let mut destinations: Vec<SharedString> = Vec::new();
for span in spans {
let span = span.borrow();
let start = text.len();
text.push_str(&span.text);
let range = start..text.len();
match &span.style {
InlineStyle::Text => {}
InlineStyle::Emphasis => highlights.push((
range,
HighlightStyle {
font_style: Some(FontStyle::Italic),
..Default::default()
},
)),
InlineStyle::Strong => highlights.push((
range,
HighlightStyle {
font_weight: Some(FontWeight::SEMIBOLD),
..Default::default()
},
)),
InlineStyle::StrongEmphasis => highlights.push((
range,
HighlightStyle {
font_style: Some(FontStyle::Italic),
font_weight: Some(FontWeight::SEMIBOLD),
..Default::default()
},
)),
InlineStyle::Strikethrough => highlights.push((
range,
HighlightStyle {
strikethrough: Some(StrikethroughStyle {
thickness: BORDER_WIDTH,
color: Some(theme.colors.muted_foreground),
}),
..Default::default()
},
)),
InlineStyle::Code => {
highlights.push((
range.clone(),
HighlightStyle {
background_color: Some(theme.colors.muted),
..Default::default()
},
));
family_overrides.push((range, SharedString::from(theme.mono_font)));
}
InlineStyle::Link { destination } => {
highlights.push((
range.clone(),
HighlightStyle {
color: Some(theme.ramps.primary.base),
underline: Some(UnderlineStyle {
thickness: BORDER_WIDTH,
color: None,
wavy: false,
}),
..Default::default()
},
));
link_ranges.push(range);
destinations.push(destination.clone());
}
}
}
if let Some(local) = piece.as_ref().and_then(|piece| piece.selected.clone()) {
highlights.push((
local,
HighlightStyle {
background_color: Some(theme.colors.selection),
..Default::default()
},
));
}
let styled = StyledText::new(text)
.with_highlights(highlights)
.with_font_family_overrides(family_overrides);
let layout = styled.layout().clone();
let inner = if destinations.is_empty() {
styled.into_any_element()
} else {
let link_handler = piece.as_ref().and_then(|piece| piece.link_handler.clone());
InteractiveText::new(id.clone(), styled)
.on_click(link_ranges, move |range_ix, window, cx| {
let Some(destination) = destinations.get(range_ix) else {
return;
};
match link_handler.as_ref() {
Some(handler) => handler(destination, window, cx),
None => cx.open_url(destination.as_ref()),
}
})
.into_any_element()
};
let mut element = div().child(inner);
if let Some(piece) = piece {
element = with_selection_handlers(element, Some(piece), layout);
}
element.into_any_element()
}