Max Brunsfeld created
Render markdown more correctly in the editor hover popoverCargo.lock | 2
crates/collab/src/tests/integration_tests.rs | 8
crates/editor/Cargo.toml | 1
crates/editor/src/editor.rs | 4
crates/editor/src/hover_popover.rs | 550 ++++++++++++++++++---
crates/gpui/examples/text.rs | 143 +---
crates/gpui/src/elements/text.rs | 141 +++++
crates/gpui/src/text_layout.rs | 122 +++-
crates/project/Cargo.toml | 2
crates/project/src/lsp_command.rs | 118 ++--
crates/project/src/project.rs | 27
crates/rpc/proto/zed.proto | 1
crates/theme/src/theme.rs | 2
crates/theme/src/theme_registry.rs | 11
14 files changed, 826 insertions(+), 306 deletions(-)
@@ -1994,6 +1994,7 @@ dependencies = [
"parking_lot 0.11.2",
"postage",
"project",
+ "pulldown-cmark",
"rand 0.8.5",
"rpc",
"serde",
@@ -4727,7 +4728,6 @@ dependencies = [
"parking_lot 0.11.2",
"postage",
"pretty_assertions",
- "pulldown-cmark",
"rand 0.8.5",
"regex",
"rpc",
@@ -23,7 +23,7 @@ use language::{
};
use live_kit_client::MacOSDisplay;
use lsp::LanguageServerId;
-use project::{search::SearchQuery, DiagnosticSummary, Project, ProjectPath};
+use project::{search::SearchQuery, DiagnosticSummary, HoverBlockKind, Project, ProjectPath};
use rand::prelude::*;
use serde_json::json;
use settings::{Formatter, Settings};
@@ -4693,11 +4693,13 @@ async fn test_lsp_hover(
vec![
project::HoverBlock {
text: "Test hover content.".to_string(),
- language: None,
+ kind: HoverBlockKind::Markdown,
},
project::HoverBlock {
text: "let foo = 42;".to_string(),
- language: Some("Rust".to_string()),
+ kind: HoverBlockKind::Code {
+ language: "Rust".to_string()
+ },
}
]
);
@@ -55,6 +55,7 @@ log.workspace = true
ordered-float.workspace = true
parking_lot.workspace = true
postage.workspace = true
+pulldown-cmark = { version = "0.9.2", default-features = false }
rand = { workspace = true, optional = true }
serde.workspace = true
serde_derive.workspace = true
@@ -463,6 +463,7 @@ pub struct EditorStyle {
pub text: TextStyle,
pub placeholder_text: Option<TextStyle>,
pub theme: theme::Editor,
+ pub theme_id: usize,
}
type CompletionId = usize;
@@ -7310,6 +7311,7 @@ fn build_style(
) -> EditorStyle {
let font_cache = cx.font_cache();
+ let theme_id = settings.theme.meta.id;
let mut theme = settings.theme.editor.clone();
let mut style = if let Some(get_field_editor_theme) = get_field_editor_theme {
let field_editor_theme = get_field_editor_theme(&settings.theme);
@@ -7323,6 +7325,7 @@ fn build_style(
text: field_editor_theme.text,
placeholder_text: field_editor_theme.placeholder_text,
theme,
+ theme_id,
}
} else {
let font_family_id = settings.buffer_font_family;
@@ -7344,6 +7347,7 @@ fn build_style(
},
placeholder_text: None,
theme,
+ theme_id,
}
};
@@ -1,15 +1,16 @@
use futures::FutureExt;
use gpui::{
actions,
- elements::{Flex, MouseEventHandler, Padding, Text},
+ elements::{Flex, MouseEventHandler, Padding, ParentElement, Text},
+ fonts::{HighlightStyle, Underline, Weight},
impl_internal_actions,
platform::{CursorStyle, MouseButton},
- AnyElement, AppContext, Axis, Element, ModelHandle, Task, ViewContext,
+ AnyElement, AppContext, CursorRegion, Element, ModelHandle, MouseRegion, Task, ViewContext,
};
-use language::{Bias, DiagnosticEntry, DiagnosticSeverity};
-use project::{HoverBlock, Project};
+use language::{Bias, DiagnosticEntry, DiagnosticSeverity, Language, LanguageRegistry};
+use project::{HoverBlock, HoverBlockKind, Project};
use settings::Settings;
-use std::{ops::Range, time::Duration};
+use std::{ops::Range, sync::Arc, time::Duration};
use util::TryFutureExt;
use crate::{
@@ -233,7 +234,8 @@ fn show_hover(
Some(InfoPopover {
project: project.clone(),
symbol_range: range,
- contents: hover_result.contents,
+ blocks: hover_result.contents,
+ rendered_content: None,
})
});
@@ -261,6 +263,225 @@ fn show_hover(
editor.hover_state.info_task = Some(task);
}
+fn render_blocks(
+ theme_id: usize,
+ blocks: &[HoverBlock],
+ language_registry: &Arc<LanguageRegistry>,
+ style: &EditorStyle,
+) -> RenderedInfo {
+ let mut text = String::new();
+ let mut highlights = Vec::new();
+ let mut region_ranges = Vec::new();
+ let mut regions = Vec::new();
+
+ for block in blocks {
+ match &block.kind {
+ HoverBlockKind::PlainText => {
+ new_paragraph(&mut text, &mut Vec::new());
+ text.push_str(&block.text);
+ }
+ HoverBlockKind::Markdown => {
+ use pulldown_cmark::{CodeBlockKind, Event, Options, Parser, Tag};
+
+ let mut bold_depth = 0;
+ let mut italic_depth = 0;
+ let mut link_url = None;
+ let mut current_language = None;
+ let mut list_stack = Vec::new();
+
+ for event in Parser::new_ext(&block.text, Options::all()) {
+ let prev_len = text.len();
+ match event {
+ Event::Text(t) => {
+ if let Some(language) = ¤t_language {
+ render_code(
+ &mut text,
+ &mut highlights,
+ t.as_ref(),
+ language,
+ style,
+ );
+ } else {
+ text.push_str(t.as_ref());
+
+ let mut style = HighlightStyle::default();
+ if bold_depth > 0 {
+ style.weight = Some(Weight::BOLD);
+ }
+ if italic_depth > 0 {
+ style.italic = Some(true);
+ }
+ if let Some(link_url) = link_url.clone() {
+ region_ranges.push(prev_len..text.len());
+ regions.push(RenderedRegion {
+ link_url: Some(link_url),
+ code: false,
+ });
+ style.underline = Some(Underline {
+ thickness: 1.0.into(),
+ ..Default::default()
+ });
+ }
+
+ if style != HighlightStyle::default() {
+ let mut new_highlight = true;
+ if let Some((last_range, last_style)) = highlights.last_mut() {
+ if last_range.end == prev_len && last_style == &style {
+ last_range.end = text.len();
+ new_highlight = false;
+ }
+ }
+ if new_highlight {
+ highlights.push((prev_len..text.len(), style));
+ }
+ }
+ }
+ }
+ Event::Code(t) => {
+ text.push_str(t.as_ref());
+ region_ranges.push(prev_len..text.len());
+ if link_url.is_some() {
+ highlights.push((
+ prev_len..text.len(),
+ HighlightStyle {
+ underline: Some(Underline {
+ thickness: 1.0.into(),
+ ..Default::default()
+ }),
+ ..Default::default()
+ },
+ ));
+ }
+ regions.push(RenderedRegion {
+ code: true,
+ link_url: link_url.clone(),
+ });
+ }
+ Event::Start(tag) => match tag {
+ Tag::Paragraph => new_paragraph(&mut text, &mut list_stack),
+ Tag::Heading(_, _, _) => {
+ new_paragraph(&mut text, &mut list_stack);
+ bold_depth += 1;
+ }
+ Tag::CodeBlock(kind) => {
+ new_paragraph(&mut text, &mut list_stack);
+ if let CodeBlockKind::Fenced(language) = kind {
+ current_language = language_registry
+ .language_for_name(language.as_ref())
+ .now_or_never()
+ .and_then(Result::ok);
+ }
+ }
+ Tag::Emphasis => italic_depth += 1,
+ Tag::Strong => bold_depth += 1,
+ Tag::Link(_, url, _) => link_url = Some(url.to_string()),
+ Tag::List(number) => {
+ list_stack.push((number, false));
+ }
+ Tag::Item => {
+ let len = list_stack.len();
+ if let Some((list_number, has_content)) = list_stack.last_mut() {
+ *has_content = false;
+ if !text.is_empty() && !text.ends_with('\n') {
+ text.push('\n');
+ }
+ for _ in 0..len - 1 {
+ text.push_str(" ");
+ }
+ if let Some(number) = list_number {
+ text.push_str(&format!("{}. ", number));
+ *number += 1;
+ *has_content = false;
+ } else {
+ text.push_str("- ");
+ }
+ }
+ }
+ _ => {}
+ },
+ Event::End(tag) => match tag {
+ Tag::Heading(_, _, _) => bold_depth -= 1,
+ Tag::CodeBlock(_) => current_language = None,
+ Tag::Emphasis => italic_depth -= 1,
+ Tag::Strong => bold_depth -= 1,
+ Tag::Link(_, _, _) => link_url = None,
+ Tag::List(_) => drop(list_stack.pop()),
+ _ => {}
+ },
+ Event::HardBreak => text.push('\n'),
+ Event::SoftBreak => text.push(' '),
+ _ => {}
+ }
+ }
+ }
+ HoverBlockKind::Code { language } => {
+ if let Some(language) = language_registry
+ .language_for_name(language)
+ .now_or_never()
+ .and_then(Result::ok)
+ {
+ render_code(&mut text, &mut highlights, &block.text, &language, style);
+ } else {
+ text.push_str(&block.text);
+ }
+ }
+ }
+ }
+
+ if !text.is_empty() && !text.ends_with('\n') {
+ text.push('\n');
+ }
+
+ RenderedInfo {
+ theme_id,
+ text,
+ highlights,
+ region_ranges,
+ regions,
+ }
+}
+
+fn render_code(
+ text: &mut String,
+ highlights: &mut Vec<(Range<usize>, HighlightStyle)>,
+ content: &str,
+ language: &Arc<Language>,
+ style: &EditorStyle,
+) {
+ let prev_len = text.len();
+ text.push_str(content);
+ for (range, highlight_id) in language.highlight_text(&content.into(), 0..content.len()) {
+ if let Some(style) = highlight_id.style(&style.syntax) {
+ highlights.push((prev_len + range.start..prev_len + range.end, style));
+ }
+ }
+}
+
+fn new_paragraph(text: &mut String, list_stack: &mut Vec<(Option<u64>, bool)>) {
+ let mut is_subsequent_paragraph_of_list = false;
+ if let Some((_, has_content)) = list_stack.last_mut() {
+ if *has_content {
+ is_subsequent_paragraph_of_list = true;
+ } else {
+ *has_content = true;
+ return;
+ }
+ }
+
+ if !text.is_empty() {
+ if !text.ends_with('\n') {
+ text.push('\n');
+ }
+ text.push('\n');
+ }
+ for _ in 0..list_stack.len().saturating_sub(1) {
+ text.push_str(" ");
+ }
+ if is_subsequent_paragraph_of_list {
+ text.push_str(" ");
+ }
+}
+
#[derive(Default)]
pub struct HoverState {
pub info_popover: Option<InfoPopover>,
@@ -275,7 +496,7 @@ impl HoverState {
}
pub fn render(
- &self,
+ &mut self,
snapshot: &EditorSnapshot,
style: &EditorStyle,
visible_rows: Range<u32>,
@@ -304,7 +525,7 @@ impl HoverState {
if let Some(diagnostic_popover) = self.diagnostic_popover.as_ref() {
elements.push(diagnostic_popover.render(style, cx));
}
- if let Some(info_popover) = self.info_popover.as_ref() {
+ if let Some(info_popover) = self.info_popover.as_mut() {
elements.push(info_popover.render(style, cx));
}
@@ -316,44 +537,92 @@ impl HoverState {
pub struct InfoPopover {
pub project: ModelHandle<Project>,
pub symbol_range: Range<Anchor>,
- pub contents: Vec<HoverBlock>,
+ pub blocks: Vec<HoverBlock>,
+ rendered_content: Option<RenderedInfo>,
+}
+
+#[derive(Debug, Clone)]
+struct RenderedInfo {
+ theme_id: usize,
+ text: String,
+ highlights: Vec<(Range<usize>, HighlightStyle)>,
+ region_ranges: Vec<Range<usize>>,
+ regions: Vec<RenderedRegion>,
+}
+
+#[derive(Debug, Clone)]
+struct RenderedRegion {
+ code: bool,
+ link_url: Option<String>,
}
impl InfoPopover {
- pub fn render(&self, style: &EditorStyle, cx: &mut ViewContext<Editor>) -> AnyElement<Editor> {
+ pub fn render(
+ &mut self,
+ style: &EditorStyle,
+ cx: &mut ViewContext<Editor>,
+ ) -> AnyElement<Editor> {
+ if let Some(rendered) = &self.rendered_content {
+ if rendered.theme_id != style.theme_id {
+ self.rendered_content = None;
+ }
+ }
+
+ let rendered_content = self.rendered_content.get_or_insert_with(|| {
+ render_blocks(
+ style.theme_id,
+ &self.blocks,
+ self.project.read(cx).languages(),
+ style,
+ )
+ });
+
MouseEventHandler::<InfoPopover, _>::new(0, cx, |_, cx| {
- let mut flex = Flex::new(Axis::Vertical).scrollable::<HoverBlock>(1, None, cx);
- flex.extend(self.contents.iter().map(|content| {
- let languages = self.project.read(cx).languages();
- if let Some(language) = content.language.clone().and_then(|language| {
- languages.language_for_name(&language).now_or_never()?.ok()
- }) {
- let runs = language
- .highlight_text(&content.text.as_str().into(), 0..content.text.len());
-
- Text::new(content.text.clone(), style.text.clone())
- .with_soft_wrap(true)
- .with_highlights(
- runs.iter()
- .filter_map(|(range, id)| {
- id.style(style.theme.syntax.as_ref())
- .map(|style| (range.clone(), style))
- })
- .collect(),
+ let mut region_id = 0;
+ let view_id = cx.view_id();
+
+ let code_span_background_color = style.document_highlight_read_background;
+ let regions = rendered_content.regions.clone();
+ Flex::column()
+ .scrollable::<HoverBlock>(1, None, cx)
+ .with_child(
+ Text::new(rendered_content.text.clone(), style.text.clone())
+ .with_highlights(rendered_content.highlights.clone())
+ .with_custom_runs(
+ rendered_content.region_ranges.clone(),
+ move |ix, bounds, scene, _| {
+ region_id += 1;
+ let region = regions[ix].clone();
+ if let Some(url) = region.link_url {
+ scene.push_cursor_region(CursorRegion {
+ bounds,
+ style: CursorStyle::PointingHand,
+ });
+ scene.push_mouse_region(
+ MouseRegion::new::<Self>(view_id, region_id, bounds)
+ .on_click::<Editor, _>(
+ MouseButton::Left,
+ move |_, _, cx| {
+ println!("clicked link {url}");
+ cx.platform().open_url(&url);
+ },
+ ),
+ );
+ }
+ if region.code {
+ scene.push_quad(gpui::Quad {
+ bounds,
+ background: Some(code_span_background_color),
+ border: Default::default(),
+ corner_radius: 2.0,
+ });
+ }
+ },
)
- .into_any()
- } else {
- let mut text_style = style.hover_popover.prose.clone();
- text_style.font_size = style.text.font_size;
-
- Text::new(content.text.clone(), text_style)
- .with_soft_wrap(true)
- .contained()
- .with_style(style.hover_popover.block_style)
- .into_any()
- }
- }));
- flex.contained().with_style(style.hover_popover.container)
+ .with_soft_wrap(true),
+ )
+ .contained()
+ .with_style(style.hover_popover.container)
})
.on_move(|_, _, _| {}) // Consume move events so they don't reach regions underneath.
.with_cursor_style(CursorStyle::Arrow)
@@ -437,16 +706,16 @@ impl DiagnosticPopover {
#[cfg(test)]
mod tests {
+ use super::*;
+ use crate::test::editor_lsp_test_context::EditorLspTestContext;
+ use gpui::fonts::Weight;
use indoc::indoc;
-
use language::{Diagnostic, DiagnosticSet};
use lsp::LanguageServerId;
- use project::HoverBlock;
+ use project::{HoverBlock, HoverBlockKind};
use smol::stream::StreamExt;
-
- use crate::test::editor_lsp_test_context::EditorLspTestContext;
-
- use super::*;
+ use unindent::Unindent;
+ use util::test::marked_text_ranges;
#[gpui::test]
async fn test_mouse_hover_info_popover(cx: &mut gpui::TestAppContext) {
@@ -487,10 +756,7 @@ mod tests {
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Markup(lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
- value: indoc! {"
- # Some basic docs
- Some test documentation"}
- .to_string(),
+ value: "some basic docs".to_string(),
}),
range: Some(symbol_range),
}))
@@ -502,17 +768,11 @@ mod tests {
cx.editor(|editor, _| {
assert!(editor.hover_state.visible());
assert_eq!(
- editor.hover_state.info_popover.clone().unwrap().contents,
- vec![
- HoverBlock {
- text: "Some basic docs".to_string(),
- language: None
- },
- HoverBlock {
- text: "Some test documentation".to_string(),
- language: None
- }
- ]
+ editor.hover_state.info_popover.clone().unwrap().blocks,
+ vec![HoverBlock {
+ text: "some basic docs".to_string(),
+ kind: HoverBlockKind::Markdown,
+ },]
)
});
@@ -563,10 +823,7 @@ mod tests {
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Markup(lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
- value: indoc! {"
- # Some other basic docs
- Some other test documentation"}
- .to_string(),
+ value: "some other basic docs".to_string(),
}),
range: Some(symbol_range),
}))
@@ -577,17 +834,11 @@ mod tests {
cx.condition(|editor, _| editor.hover_state.visible()).await;
cx.editor(|editor, _| {
assert_eq!(
- editor.hover_state.info_popover.clone().unwrap().contents,
- vec![
- HoverBlock {
- text: "Some other basic docs".to_string(),
- language: None
- },
- HoverBlock {
- text: "Some other test documentation".to_string(),
- language: None
- }
- ]
+ editor.hover_state.info_popover.clone().unwrap().blocks,
+ vec![HoverBlock {
+ text: "some other basic docs".to_string(),
+ kind: HoverBlockKind::Markdown,
+ }]
)
});
}
@@ -644,10 +895,7 @@ mod tests {
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Markup(lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
- value: indoc! {"
- # Some other basic docs
- Some other test documentation"}
- .to_string(),
+ value: "some new docs".to_string(),
}),
range: Some(range),
}))
@@ -660,4 +908,144 @@ mod tests {
hover_state.diagnostic_popover.is_some() && hover_state.info_task.is_some()
});
}
+
+ #[gpui::test]
+ fn test_render_blocks(cx: &mut gpui::TestAppContext) {
+ Settings::test_async(cx);
+ cx.add_window(|cx| {
+ let editor = Editor::single_line(None, cx);
+ let style = editor.style(cx);
+
+ struct Row {
+ blocks: Vec<HoverBlock>,
+ expected_marked_text: String,
+ expected_styles: Vec<HighlightStyle>,
+ }
+
+ let rows = &[
+ // Strong emphasis
+ Row {
+ blocks: vec![HoverBlock {
+ text: "one **two** three".to_string(),
+ kind: HoverBlockKind::Markdown,
+ }],
+ expected_marked_text: "one «two» three\n".to_string(),
+ expected_styles: vec![HighlightStyle {
+ weight: Some(Weight::BOLD),
+ ..Default::default()
+ }],
+ },
+ // Links
+ Row {
+ blocks: vec three".to_string(),
+ kind: HoverBlockKind::Markdown,
+ }],
+ expected_marked_text: "one «two» three\n".to_string(),
+ expected_styles: vec![HighlightStyle {
+ underline: Some(Underline {
+ thickness: 1.0.into(),
+ ..Default::default()
+ }),
+ ..Default::default()
+ }],
+ },
+ // Lists
+ Row {
+ blocks: vec
+ - d
+ "
+ .unindent(),
+ kind: HoverBlockKind::Markdown,
+ }],
+ expected_marked_text: "
+ lists:
+ - one
+ - a
+ - b
+ - two
+ - «c»
+ - d
+ "
+ .unindent(),
+ expected_styles: vec![HighlightStyle {
+ underline: Some(Underline {
+ thickness: 1.0.into(),
+ ..Default::default()
+ }),
+ ..Default::default()
+ }],
+ },
+ // Multi-paragraph list items
+ Row {
+ blocks: vec![HoverBlock {
+ text: "
+ * one two
+ three
+
+ * four five
+ * six seven
+ eight
+
+ nine
+ * ten
+ * six
+ "
+ .unindent(),
+ kind: HoverBlockKind::Markdown,
+ }],
+ expected_marked_text: "
+ - one two three
+ - four five
+ - six seven eight
+
+ nine
+ - ten
+ - six
+ "
+ .unindent(),
+ expected_styles: vec![HighlightStyle {
+ underline: Some(Underline {
+ thickness: 1.0.into(),
+ ..Default::default()
+ }),
+ ..Default::default()
+ }],
+ },
+ ];
+
+ for Row {
+ blocks,
+ expected_marked_text,
+ expected_styles,
+ } in &rows[0..]
+ {
+ let rendered = render_blocks(0, &blocks, &Default::default(), &style);
+
+ let (expected_text, ranges) = marked_text_ranges(expected_marked_text, false);
+ let expected_highlights = ranges
+ .into_iter()
+ .zip(expected_styles.iter().cloned())
+ .collect::<Vec<_>>();
+ assert_eq!(
+ rendered.text,
+ dbg!(expected_text),
+ "wrong text for input {blocks:?}"
+ );
+ assert_eq!(
+ rendered.highlights, expected_highlights,
+ "wrong highlights for input {blocks:?}"
+ );
+ }
+
+ editor
+ });
+ }
}
@@ -1,13 +1,12 @@
use gpui::{
color::Color,
- fonts::{Properties, Weight},
- text_layout::RunStyle,
- AnyElement, Element, Quad, SceneBuilder, View, ViewContext,
+ elements::Text,
+ fonts::{HighlightStyle, TextStyle},
+ platform::{CursorStyle, MouseButton},
+ AnyElement, CursorRegion, Element, MouseRegion,
};
use log::LevelFilter;
-use pathfinder_geometry::rect::RectF;
use simplelog::SimpleLogger;
-use std::ops::Range;
fn main() {
SimpleLogger::init(LevelFilter::Info, Default::default()).expect("could not initialize logger");
@@ -19,7 +18,6 @@ fn main() {
}
struct TextView;
-struct TextElement;
impl gpui::Entity for TextView {
type Event = ();
@@ -30,104 +28,53 @@ impl gpui::View for TextView {
"View"
}
- fn render(&mut self, _: &mut gpui::ViewContext<Self>) -> AnyElement<TextView> {
- TextElement.into_any()
- }
-}
-
-impl<V: View> Element<V> for TextElement {
- type LayoutState = ();
-
- type PaintState = ();
-
- fn layout(
- &mut self,
- constraint: gpui::SizeConstraint,
- _: &mut V,
- _: &mut ViewContext<V>,
- ) -> (pathfinder_geometry::vector::Vector2F, Self::LayoutState) {
- (constraint.max, ())
- }
-
- fn paint(
- &mut self,
- scene: &mut SceneBuilder,
- bounds: RectF,
- visible_bounds: RectF,
- _: &mut Self::LayoutState,
- _: &mut V,
- cx: &mut ViewContext<V>,
- ) -> Self::PaintState {
+ fn render(&mut self, cx: &mut gpui::ViewContext<Self>) -> AnyElement<TextView> {
let font_size = 12.;
let family = cx
.font_cache
- .load_family(&["SF Pro Display"], &Default::default())
+ .load_family(&["Monaco"], &Default::default())
.unwrap();
- let normal = RunStyle {
- font_id: cx
- .font_cache
- .select_font(family, &Default::default())
- .unwrap(),
- color: Color::default(),
- underline: Default::default(),
- };
- let bold = RunStyle {
- font_id: cx
- .font_cache
- .select_font(
- family,
- &Properties {
- weight: Weight::BOLD,
- ..Default::default()
- },
- )
- .unwrap(),
- color: Color::default(),
- underline: Default::default(),
- };
-
- let text = "Hello world!";
- let line = cx.text_layout_cache().layout_str(
- text,
- font_size,
- &[
- (1, normal),
- (1, bold),
- (1, normal),
- (1, bold),
- (text.len() - 4, normal),
- ],
- );
+ let font_id = cx
+ .font_cache
+ .select_font(family, &Default::default())
+ .unwrap();
+ let view_id = cx.view_id();
- scene.push_quad(Quad {
- bounds,
- background: Some(Color::white()),
+ let underline = HighlightStyle {
+ underline: Some(gpui::fonts::Underline {
+ thickness: 1.0.into(),
+ ..Default::default()
+ }),
..Default::default()
- });
- line.paint(scene, bounds.origin(), visible_bounds, bounds.height(), cx);
- }
-
- fn rect_for_text_range(
- &self,
- _: Range<usize>,
- _: RectF,
- _: RectF,
- _: &Self::LayoutState,
- _: &Self::PaintState,
- _: &V,
- _: &ViewContext<V>,
- ) -> Option<RectF> {
- None
- }
+ };
- fn debug(
- &self,
- _: RectF,
- _: &Self::LayoutState,
- _: &Self::PaintState,
- _: &V,
- _: &ViewContext<V>,
- ) -> gpui::json::Value {
- todo!()
+ Text::new(
+ "The text:\nHello, beautiful world, hello!",
+ TextStyle {
+ font_id,
+ font_size,
+ color: Color::red(),
+ font_family_name: "".into(),
+ font_family_id: family,
+ underline: Default::default(),
+ font_properties: Default::default(),
+ },
+ )
+ .with_highlights(vec![(17..26, underline), (34..40, underline)])
+ .with_custom_runs(vec![(17..26), (34..40)], move |ix, bounds, scene, _| {
+ scene.push_cursor_region(CursorRegion {
+ bounds,
+ style: CursorStyle::PointingHand,
+ });
+ scene.push_mouse_region(
+ MouseRegion::new::<Self>(view_id, ix, bounds).on_click::<Self, _>(
+ MouseButton::Left,
+ move |_, _, _| {
+ eprintln!("clicked link {ix}");
+ },
+ ),
+ );
+ })
+ .into_any()
}
}
@@ -7,7 +7,8 @@ use crate::{
},
json::{ToJson, Value},
text_layout::{Line, RunStyle, ShapedBoundary},
- Element, FontCache, SceneBuilder, SizeConstraint, TextLayoutCache, View, ViewContext,
+ AppContext, Element, FontCache, SceneBuilder, SizeConstraint, TextLayoutCache, View,
+ ViewContext,
};
use log::warn;
use serde_json::json;
@@ -17,7 +18,11 @@ pub struct Text {
text: Cow<'static, str>,
style: TextStyle,
soft_wrap: bool,
- highlights: Vec<(Range<usize>, HighlightStyle)>,
+ highlights: Option<Box<[(Range<usize>, HighlightStyle)]>>,
+ custom_runs: Option<(
+ Box<[Range<usize>]>,
+ Box<dyn FnMut(usize, RectF, &mut SceneBuilder, &mut AppContext)>,
+ )>,
}
pub struct LayoutState {
@@ -32,7 +37,8 @@ impl Text {
text: text.into(),
style,
soft_wrap: true,
- highlights: Vec::new(),
+ highlights: None,
+ custom_runs: None,
}
}
@@ -41,8 +47,20 @@ impl Text {
self
}
- pub fn with_highlights(mut self, runs: Vec<(Range<usize>, HighlightStyle)>) -> Self {
- self.highlights = runs;
+ pub fn with_highlights(
+ mut self,
+ runs: impl Into<Box<[(Range<usize>, HighlightStyle)]>>,
+ ) -> Self {
+ self.highlights = Some(runs.into());
+ self
+ }
+
+ pub fn with_custom_runs(
+ mut self,
+ runs: impl Into<Box<[Range<usize>]>>,
+ callback: impl 'static + FnMut(usize, RectF, &mut SceneBuilder, &mut AppContext),
+ ) -> Self {
+ self.custom_runs = Some((runs.into(), Box::new(callback)));
self
}
@@ -65,7 +83,12 @@ impl<V: View> Element<V> for Text {
// Convert the string and highlight ranges into an iterator of highlighted chunks.
let mut offset = 0;
- let mut highlight_ranges = self.highlights.iter().peekable();
+ let mut highlight_ranges = self
+ .highlights
+ .as_ref()
+ .map_or(Default::default(), AsRef::as_ref)
+ .iter()
+ .peekable();
let chunks = std::iter::from_fn(|| {
let result;
if let Some((range, highlight_style)) = highlight_ranges.peek() {
@@ -152,6 +175,20 @@ impl<V: View> Element<V> for Text {
) -> Self::PaintState {
let mut origin = bounds.origin();
let empty = Vec::new();
+ let mut callback = |_, _, _: &mut SceneBuilder, _: &mut AppContext| {};
+
+ let mouse_runs;
+ let custom_run_callback;
+ if let Some((runs, build_region)) = &mut self.custom_runs {
+ mouse_runs = runs.iter();
+ custom_run_callback = build_region.as_mut();
+ } else {
+ mouse_runs = [].iter();
+ custom_run_callback = &mut callback;
+ }
+ let mut custom_runs = mouse_runs.enumerate().peekable();
+
+ let mut offset = 0;
for (ix, line) in layout.shaped_lines.iter().enumerate() {
let wrap_boundaries = layout.wrap_boundaries.get(ix).unwrap_or(&empty);
let boundaries = RectF::new(
@@ -169,13 +206,103 @@ impl<V: View> Element<V> for Text {
origin,
visible_bounds,
layout.line_height,
- wrap_boundaries.iter().copied(),
+ wrap_boundaries,
cx,
);
} else {
line.paint(scene, origin, visible_bounds, layout.line_height, cx);
}
}
+
+ // Paint any custom runs that intersect this line.
+ let end_offset = offset + line.len();
+ if let Some((custom_run_ix, custom_run_range)) = custom_runs.peek().cloned() {
+ if custom_run_range.start < end_offset {
+ let mut current_custom_run = None;
+ if custom_run_range.start <= offset {
+ current_custom_run = Some((custom_run_ix, custom_run_range.end, origin));
+ }
+
+ let mut glyph_origin = origin;
+ let mut prev_position = 0.;
+ let mut wrap_boundaries = wrap_boundaries.iter().copied().peekable();
+ for (run_ix, glyph_ix, glyph) in
+ line.runs().iter().enumerate().flat_map(|(run_ix, run)| {
+ run.glyphs()
+ .iter()
+ .enumerate()
+ .map(move |(ix, glyph)| (run_ix, ix, glyph))
+ })
+ {
+ glyph_origin.set_x(glyph_origin.x() + glyph.position.x() - prev_position);
+ prev_position = glyph.position.x();
+
+ // If we've reached a soft wrap position, move down one line. If there
+ // is a custom run in-progress, paint it.
+ if wrap_boundaries
+ .peek()
+ .map_or(false, |b| b.run_ix == run_ix && b.glyph_ix == glyph_ix)
+ {
+ if let Some((run_ix, _, run_origin)) = &mut current_custom_run {
+ let bounds = RectF::from_points(
+ *run_origin,
+ glyph_origin + vec2f(0., layout.line_height),
+ );
+ custom_run_callback(*run_ix, bounds, scene, cx);
+ *run_origin =
+ vec2f(origin.x(), glyph_origin.y() + layout.line_height);
+ }
+ wrap_boundaries.next();
+ glyph_origin = vec2f(origin.x(), glyph_origin.y() + layout.line_height);
+ }
+
+ // If we've reached the end of the current custom run, paint it.
+ if let Some((run_ix, run_end_offset, run_origin)) = current_custom_run {
+ if offset + glyph.index == run_end_offset {
+ current_custom_run.take();
+ let bounds = RectF::from_points(
+ run_origin,
+ glyph_origin + vec2f(0., layout.line_height),
+ );
+ custom_run_callback(run_ix, bounds, scene, cx);
+ custom_runs.next();
+ }
+
+ if let Some((_, run_range)) = custom_runs.peek() {
+ if run_range.start >= end_offset {
+ break;
+ }
+ if run_range.start == offset + glyph.index {
+ current_custom_run =
+ Some((run_ix, run_range.end, glyph_origin));
+ }
+ }
+ }
+
+ // If we've reached the start of a new custom run, start tracking it.
+ if let Some((run_ix, run_range)) = custom_runs.peek() {
+ if offset + glyph.index == run_range.start {
+ current_custom_run = Some((*run_ix, run_range.end, glyph_origin));
+ }
+ }
+ }
+
+ // If a custom run extends beyond the end of the line, paint it.
+ if let Some((run_ix, run_end_offset, run_origin)) = current_custom_run {
+ let line_end = glyph_origin + vec2f(line.width() - prev_position, 0.);
+ let bounds = RectF::from_points(
+ run_origin,
+ line_end + vec2f(0., layout.line_height),
+ );
+ custom_run_callback(run_ix, bounds, scene, cx);
+ if end_offset == run_end_offset {
+ custom_runs.next();
+ }
+ }
+ }
+ }
+
+ offset = end_offset + 1;
origin.set_y(boundaries.max_y());
}
}
@@ -177,7 +177,14 @@ impl<'a> Hash for CacheKeyRef<'a> {
#[derive(Default, Debug, Clone)]
pub struct Line {
layout: Arc<LineLayout>,
- style_runs: SmallVec<[(u32, Color, Underline); 32]>,
+ style_runs: SmallVec<[StyleRun; 32]>,
+}
+
+#[derive(Debug, Clone, Copy)]
+struct StyleRun {
+ len: u32,
+ color: Color,
+ underline: Underline,
}
#[derive(Default, Debug)]
@@ -208,7 +215,11 @@ impl Line {
fn new(layout: Arc<LineLayout>, runs: &[(usize, RunStyle)]) -> Self {
let mut style_runs = SmallVec::new();
for (len, style) in runs {
- style_runs.push((*len as u32, style.color, style.underline));
+ style_runs.push(StyleRun {
+ len: *len as u32,
+ color: style.color,
+ underline: style.underline,
+ });
}
Self { layout, style_runs }
}
@@ -301,28 +312,30 @@ impl Line {
let mut finished_underline = None;
if glyph.index >= run_end {
- if let Some((run_len, run_color, run_underline)) = style_runs.next() {
+ if let Some(style_run) = style_runs.next() {
if let Some((_, underline_style)) = underline {
- if *run_underline != underline_style {
+ if style_run.underline != underline_style {
finished_underline = underline.take();
}
}
- if run_underline.thickness.into_inner() > 0. {
+ if style_run.underline.thickness.into_inner() > 0. {
underline.get_or_insert((
vec2f(
glyph_origin.x(),
origin.y() + baseline_offset.y() + 0.618 * self.layout.descent,
),
Underline {
- color: Some(run_underline.color.unwrap_or(*run_color)),
- thickness: run_underline.thickness,
- squiggly: run_underline.squiggly,
+ color: Some(
+ style_run.underline.color.unwrap_or(style_run.color),
+ ),
+ thickness: style_run.underline.thickness,
+ squiggly: style_run.underline.squiggly,
},
));
}
- run_end += *run_len as usize;
- color = *run_color;
+ run_end += style_run.len as usize;
+ color = style_run.color;
} else {
run_end = self.layout.len;
finished_underline = underline.take();
@@ -380,41 +393,85 @@ impl Line {
origin: Vector2F,
visible_bounds: RectF,
line_height: f32,
- boundaries: impl IntoIterator<Item = ShapedBoundary>,
+ boundaries: &[ShapedBoundary],
cx: &mut WindowContext,
) {
let padding_top = (line_height - self.layout.ascent - self.layout.descent) / 2.;
- let baseline_origin = vec2f(0., padding_top + self.layout.ascent);
+ let baseline_offset = vec2f(0., padding_top + self.layout.ascent);
let mut boundaries = boundaries.into_iter().peekable();
let mut color_runs = self.style_runs.iter();
- let mut color_end = 0;
+ let mut style_run_end = 0;
let mut color = Color::black();
+ let mut underline: Option<(Vector2F, Underline)> = None;
- let mut glyph_origin = vec2f(0., 0.);
+ let mut glyph_origin = origin;
let mut prev_position = 0.;
- for run in &self.layout.runs {
+ for (run_ix, run) in self.layout.runs.iter().enumerate() {
for (glyph_ix, glyph) in run.glyphs.iter().enumerate() {
- if boundaries.peek().map_or(false, |b| b.glyph_ix == glyph_ix) {
+ glyph_origin.set_x(glyph_origin.x() + glyph.position.x() - prev_position);
+
+ if boundaries
+ .peek()
+ .map_or(false, |b| b.run_ix == run_ix && b.glyph_ix == glyph_ix)
+ {
boundaries.next();
- glyph_origin = vec2f(0., glyph_origin.y() + line_height);
- } else {
- glyph_origin.set_x(glyph_origin.x() + glyph.position.x() - prev_position);
+ if let Some((underline_origin, underline_style)) = underline {
+ scene.push_underline(scene::Underline {
+ origin: underline_origin,
+ width: glyph_origin.x() - underline_origin.x(),
+ thickness: underline_style.thickness.into(),
+ color: underline_style.color.unwrap(),
+ squiggly: underline_style.squiggly,
+ });
+ }
+
+ glyph_origin = vec2f(origin.x(), glyph_origin.y() + line_height);
}
prev_position = glyph.position.x();
- if glyph.index >= color_end {
- if let Some(next_run) = color_runs.next() {
- color_end += next_run.0 as usize;
- color = next_run.1;
+ let mut finished_underline = None;
+ if glyph.index >= style_run_end {
+ if let Some(style_run) = color_runs.next() {
+ style_run_end += style_run.len as usize;
+ color = style_run.color;
+ if let Some((_, underline_style)) = underline {
+ if style_run.underline != underline_style {
+ finished_underline = underline.take();
+ }
+ }
+ if style_run.underline.thickness.into_inner() > 0. {
+ underline.get_or_insert((
+ glyph_origin
+ + vec2f(0., baseline_offset.y() + 0.618 * self.layout.descent),
+ Underline {
+ color: Some(
+ style_run.underline.color.unwrap_or(style_run.color),
+ ),
+ thickness: style_run.underline.thickness,
+ squiggly: style_run.underline.squiggly,
+ },
+ ));
+ }
} else {
- color_end = self.layout.len;
+ style_run_end = self.layout.len;
color = Color::black();
+ finished_underline = underline.take();
}
}
+ if let Some((underline_origin, underline_style)) = finished_underline {
+ scene.push_underline(scene::Underline {
+ origin: underline_origin,
+ width: glyph_origin.x() - underline_origin.x(),
+ thickness: underline_style.thickness.into(),
+ color: underline_style.color.unwrap(),
+ squiggly: underline_style.squiggly,
+ });
+ }
+
let glyph_bounds = RectF::new(
- origin + glyph_origin,
+ glyph_origin,
cx.font_cache
.bounding_box(run.font_id, self.layout.font_size),
);
@@ -424,20 +481,31 @@ impl Line {
font_id: run.font_id,
font_size: self.layout.font_size,
id: glyph.id,
- origin: glyph_bounds.origin() + baseline_origin,
+ origin: glyph_bounds.origin() + baseline_offset,
});
} else {
scene.push_glyph(scene::Glyph {
font_id: run.font_id,
font_size: self.layout.font_size,
id: glyph.id,
- origin: glyph_bounds.origin() + baseline_origin,
+ origin: glyph_bounds.origin() + baseline_offset,
color,
});
}
}
}
}
+
+ if let Some((underline_origin, underline_style)) = underline.take() {
+ let line_end_x = glyph_origin.x() + self.layout.width - prev_position;
+ scene.push_underline(scene::Underline {
+ origin: underline_origin,
+ width: line_end_x - underline_origin.x(),
+ thickness: underline_style.thickness.into(),
+ color: underline_style.color.unwrap(),
+ squiggly: underline_style.squiggly,
+ });
+ }
}
}
@@ -37,6 +37,7 @@ settings = { path = "../settings" }
sum_tree = { path = "../sum_tree" }
terminal = { path = "../terminal" }
util = { path = "../util" }
+
aho-corasick = "0.7"
anyhow.workspace = true
async-trait.workspace = true
@@ -47,7 +48,6 @@ lazy_static.workspace = true
log.workspace = true
parking_lot.workspace = true
postage.workspace = true
-pulldown-cmark = { version = "0.9.1", default-features = false }
rand.workspace = true
regex.workspace = true
serde.workspace = true
@@ -1,5 +1,6 @@
use crate::{
- DocumentHighlight, Hover, HoverBlock, Location, LocationLink, Project, ProjectTransaction,
+ DocumentHighlight, Hover, HoverBlock, HoverBlockKind, Location, LocationLink, Project,
+ ProjectTransaction,
};
use anyhow::{anyhow, Result};
use async_trait::async_trait;
@@ -13,7 +14,6 @@ use language::{
Completion, OffsetRangeExt, PointUtf16, ToOffset, ToPointUtf16, Unclipped,
};
use lsp::{DocumentHighlightKind, LanguageServer, LanguageServerId, ServerCapabilities};
-use pulldown_cmark::{CodeBlockKind, Event, Options, Parser, Tag};
use std::{cmp::Reverse, ops::Range, path::Path, sync::Arc};
#[async_trait(?Send)]
@@ -1092,76 +1092,49 @@ impl LspCommand for GetHover {
})
});
+ fn hover_blocks_from_marked_string(
+ marked_string: lsp::MarkedString,
+ ) -> Option<HoverBlock> {
+ let block = match marked_string {
+ lsp::MarkedString::String(content) => HoverBlock {
+ text: content,
+ kind: HoverBlockKind::Markdown,
+ },
+ lsp::MarkedString::LanguageString(lsp::LanguageString { language, value }) => {
+ HoverBlock {
+ text: value,
+ kind: HoverBlockKind::Code { language },
+ }
+ }
+ };
+ if block.text.is_empty() {
+ None
+ } else {
+ Some(block)
+ }
+ }
+
let contents = cx.read(|_| match hover.contents {
lsp::HoverContents::Scalar(marked_string) => {
- HoverBlock::try_new(marked_string).map(|contents| vec![contents])
- }
- lsp::HoverContents::Array(marked_strings) => {
- let content: Vec<HoverBlock> = marked_strings
+ hover_blocks_from_marked_string(marked_string)
.into_iter()
- .filter_map(HoverBlock::try_new)
- .collect();
- if content.is_empty() {
- None
- } else {
- Some(content)
- }
+ .collect()
}
- lsp::HoverContents::Markup(markup_content) => {
- let mut contents = Vec::new();
- let mut language = None;
- let mut current_text = String::new();
- for event in Parser::new_ext(&markup_content.value, Options::all()) {
- match event {
- Event::SoftBreak => {
- current_text.push(' ');
- }
- Event::Text(text) | Event::Code(text) => {
- current_text.push_str(&text.to_string());
- }
- Event::Start(Tag::CodeBlock(CodeBlockKind::Fenced(new_language))) => {
- if !current_text.is_empty() {
- let text = std::mem::take(&mut current_text).trim().to_string();
- contents.push(HoverBlock { text, language });
- }
-
- language = if new_language.is_empty() {
- None
- } else {
- Some(new_language.to_string())
- };
- }
- Event::End(Tag::CodeBlock(_))
- | Event::End(Tag::Paragraph)
- | Event::End(Tag::Heading(_, _, _))
- | Event::End(Tag::BlockQuote)
- | Event::HardBreak => {
- if !current_text.is_empty() {
- let text = std::mem::take(&mut current_text).trim().to_string();
- contents.push(HoverBlock { text, language });
- }
- language = None;
- }
- _ => {}
- }
- }
-
- if !current_text.trim().is_empty() {
- contents.push(HoverBlock {
- text: current_text,
- language,
- });
- }
-
- if contents.is_empty() {
- None
+ lsp::HoverContents::Array(marked_strings) => marked_strings
+ .into_iter()
+ .filter_map(hover_blocks_from_marked_string)
+ .collect(),
+ lsp::HoverContents::Markup(markup_content) => vec![HoverBlock {
+ text: markup_content.value,
+ kind: if markup_content.kind == lsp::MarkupKind::Markdown {
+ HoverBlockKind::Markdown
} else {
- Some(contents)
- }
- }
+ HoverBlockKind::PlainText
+ },
+ }],
});
- contents.map(|contents| Hover { contents, range })
+ Some(Hover { contents, range })
}))
}
@@ -1218,7 +1191,12 @@ impl LspCommand for GetHover {
.into_iter()
.map(|block| proto::HoverBlock {
text: block.text,
- language: block.language,
+ is_markdown: block.kind == HoverBlockKind::Markdown,
+ language: if let HoverBlockKind::Code { language } = block.kind {
+ Some(language)
+ } else {
+ None
+ },
})
.collect();
@@ -1255,7 +1233,13 @@ impl LspCommand for GetHover {
.into_iter()
.map(|block| HoverBlock {
text: block.text,
- language: block.language,
+ kind: if let Some(language) = block.language {
+ HoverBlockKind::Code { language }
+ } else if block.is_markdown {
+ HoverBlockKind::Markdown
+ } else {
+ HoverBlockKind::PlainText
+ },
})
.collect();
@@ -36,7 +36,7 @@ use language::{
};
use lsp::{
DiagnosticSeverity, DiagnosticTag, DidChangeWatchedFilesRegistrationOptions,
- DocumentHighlightKind, LanguageServer, LanguageServerId, LanguageString, MarkedString,
+ DocumentHighlightKind, LanguageServer, LanguageServerId,
};
use lsp_command::*;
use lsp_glob_set::LspGlobSet;
@@ -287,27 +287,14 @@ pub struct Symbol {
#[derive(Clone, Debug, PartialEq)]
pub struct HoverBlock {
pub text: String,
- pub language: Option<String>,
+ pub kind: HoverBlockKind,
}
-impl HoverBlock {
- fn try_new(marked_string: MarkedString) -> Option<Self> {
- let result = match marked_string {
- MarkedString::LanguageString(LanguageString { language, value }) => HoverBlock {
- text: value,
- language: Some(language),
- },
- MarkedString::String(text) => HoverBlock {
- text,
- language: None,
- },
- };
- if result.text.is_empty() {
- None
- } else {
- Some(result)
- }
- }
+#[derive(Clone, Debug, PartialEq)]
+pub enum HoverBlockKind {
+ PlainText,
+ Markdown,
+ Code { language: String },
}
#[derive(Debug)]
@@ -633,6 +633,7 @@ message GetHoverResponse {
message HoverBlock {
string text = 1;
optional string language = 2;
+ bool is_markdown = 3;
}
message ApplyCodeAction {
@@ -46,6 +46,8 @@ pub struct Theme {
#[derive(Deserialize, Default, Clone)]
pub struct ThemeMeta {
+ #[serde(skip_deserializing)]
+ pub id: usize,
pub name: String,
pub is_light: bool,
}
@@ -4,13 +4,20 @@ use gpui::{fonts, AssetSource, FontCache};
use parking_lot::Mutex;
use serde::Deserialize;
use serde_json::Value;
-use std::{collections::HashMap, sync::Arc};
+use std::{
+ collections::HashMap,
+ sync::{
+ atomic::{AtomicUsize, Ordering::SeqCst},
+ Arc,
+ },
+};
pub struct ThemeRegistry {
assets: Box<dyn AssetSource>,
themes: Mutex<HashMap<String, Arc<Theme>>>,
theme_data: Mutex<HashMap<String, Arc<Value>>>,
font_cache: Arc<FontCache>,
+ next_theme_id: AtomicUsize,
}
impl ThemeRegistry {
@@ -19,6 +26,7 @@ impl ThemeRegistry {
assets: Box::new(source),
themes: Default::default(),
theme_data: Default::default(),
+ next_theme_id: Default::default(),
font_cache,
})
}
@@ -66,6 +74,7 @@ impl ThemeRegistry {
// Reset name to be the file path, so that we can use it to access the stored themes
theme.meta.name = name.into();
+ theme.meta.id = self.next_theme_id.fetch_add(1, SeqCst);
let theme: Arc<Theme> = theme.into();
self.themes.lock().insert(name.to_string(), theme.clone());
Ok(theme)