1use std::{ops::Range, rc::Rc, sync::Arc};
2
3use gpui::{AnyElement, Context, HighlightStyle, Hsla, SharedString, Window};
4use ropey::Rope;
5
6use super::{EditorState, FoldRange, InputEdit};
7use crate::SemanticThemeTokens;
8
9pub trait HighlightStyleResolver: Send + Sync {
14 fn style(&self, name: &str) -> Option<HighlightStyle>;
15}
16
17#[derive(Default)]
18struct NoHighlightStyles;
19
20impl HighlightStyleResolver for NoHighlightStyles {
21 fn style(&self, _: &str) -> Option<HighlightStyle> {
22 None
23 }
24}
25
26pub trait InputHighlighter {
31 fn language(&self) -> SharedString;
32
33 fn update(
34 &mut self,
35 edit: Option<InputEdit>,
36 text: &Rope,
37 folding: bool,
38 window: &mut Window,
39 cx: &mut Context<EditorState>,
40 );
41
42 fn styles(
45 &self,
46 range: &Range<usize>,
47 resolver: &dyn HighlightStyleResolver,
48 ) -> Vec<(Range<usize>, HighlightStyle)>;
49
50 fn fold_ranges(&self, text: &Rope) -> Vec<FoldRange>;
51
52 fn fold_ranges_for_edit(&self, range: Range<usize>, text: &Rope) -> Vec<FoldRange> {
53 let _ = range;
54 self.fold_ranges(text)
55 }
56}
57
58pub type InputHighlighterFactory = Rc<dyn Fn(&str) -> Option<Box<dyn InputHighlighter>>>;
59pub type SharedHighlightStyleResolver = Arc<dyn HighlightStyleResolver>;
60pub type FoldIconRenderer = Rc<dyn Fn(usize, bool) -> AnyElement>;
61
62#[derive(Clone, Copy, Default)]
63pub struct DiagnosticColors {
64 pub error: Hsla,
65 pub warning: Hsla,
66 pub info: Hsla,
67 pub hint: Hsla,
68}
69
70#[derive(Clone)]
72pub struct InputEditorStyle {
73 pub foreground: Hsla,
74 pub muted_foreground: Hsla,
75 pub background: Hsla,
76 pub border: Hsla,
77 pub selection: Hsla,
78 pub caret: Hsla,
79 pub diagnostics: DiagnosticColors,
80 pub highlight_styles: SharedHighlightStyleResolver,
81 pub editor_invisible: Option<Hsla>,
82 pub editor_active_line: Option<Hsla>,
83 pub editor_gutter_background: Option<Hsla>,
84 pub fold_icon_renderer: Option<FoldIconRenderer>,
85}
86
87impl InputEditorStyle {
88 pub fn resolved(&self, tokens: &SemanticThemeTokens) -> Self {
101 let colors = &tokens.colors;
102 let unset = |value: Hsla| value.alpha == 0.;
103 let or = |value: Hsla, fallback: Hsla| if unset(value) { fallback } else { value };
104
105 let foreground = or(self.foreground, colors.foreground);
106 let mut selection = self.selection;
107 if unset(selection) {
108 selection = colors.accent;
109 selection.alpha = 0.4;
111 }
112
113 Self {
114 foreground,
115 muted_foreground: or(self.muted_foreground, colors.muted_foreground),
116 background: or(self.background, colors.surface),
117 border: or(self.border, colors.border),
118 selection,
119 caret: or(self.caret, foreground),
120 ..self.clone()
121 }
122 }
123}
124
125impl Default for InputEditorStyle {
126 fn default() -> Self {
127 let unset = gpui::transparent_black();
128 Self {
129 foreground: unset,
130 muted_foreground: unset,
131 background: unset,
132 border: unset,
133 selection: unset,
134 caret: unset,
135 diagnostics: DiagnosticColors::default(),
136 highlight_styles: Arc::new(NoHighlightStyles),
137 editor_invisible: None,
138 editor_active_line: None,
139 editor_gutter_background: None,
140 fold_icon_renderer: None,
141 }
142 }
143}
144
145#[cfg(test)]
146mod tests {
147 use gpui::hsla;
148
149 use super::InputEditorStyle;
150 use crate::SemanticThemeTokens;
151
152 fn dark() -> SemanticThemeTokens {
153 let mut tokens = SemanticThemeTokens::default();
154 tokens.colors.foreground = hsla(0., 0., 0.98, 1.0);
155 tokens.colors.muted_foreground = hsla(0., 0., 0.64, 1.0);
156 tokens.colors.surface = hsla(0., 0., 0.04, 1.0);
157 tokens.colors.border = hsla(0., 0., 0.15, 1.0);
158 tokens.colors.accent = hsla(0.6, 0.5, 0.5, 1.0);
159 tokens
160 }
161
162 #[test]
163 fn an_unprojected_style_takes_its_ink_from_the_palette() {
164 let tokens = dark();
165 let resolved = InputEditorStyle::default().resolved(&tokens);
166
167 assert_eq!(resolved.foreground, tokens.colors.foreground);
168 assert_eq!(resolved.caret, tokens.colors.foreground);
169 assert_eq!(resolved.muted_foreground, tokens.colors.muted_foreground);
170 assert_eq!(resolved.background, tokens.colors.surface);
171 assert_eq!(resolved.border, tokens.colors.border);
172 for colour in [
175 resolved.foreground,
176 resolved.caret,
177 resolved.muted_foreground,
178 resolved.selection,
179 ] {
180 assert!(colour.alpha > 0., "{colour:?} is still invisible");
181 }
182 }
183
184 #[test]
185 fn a_selection_stays_translucent_enough_to_read_through() {
186 let resolved = InputEditorStyle::default().resolved(&dark());
187 assert_eq!(resolved.selection.alpha, 0.4);
188 }
189
190 #[test]
191 fn projected_colours_are_kept_verbatim() {
192 let chosen = hsla(0.3, 0.4, 0.5, 1.0);
193 let style = InputEditorStyle {
194 foreground: chosen,
195 caret: chosen,
196 ..Default::default()
197 };
198 let resolved = style.resolved(&dark());
199
200 assert_eq!(resolved.foreground, chosen);
201 assert_eq!(resolved.caret, chosen);
202 assert_eq!(resolved.border, dark().colors.border);
204 }
205
206 #[test]
207 fn resolution_never_consumes_its_own_output() {
208 let projected = InputEditorStyle::default();
212 let first = projected.resolved(&dark());
213
214 let mut light = SemanticThemeTokens::default();
215 light.colors.foreground = hsla(0., 0., 0.04, 1.0);
216 let second = projected.resolved(&light);
217
218 assert_ne!(first.foreground, second.foreground);
219 assert_eq!(second.foreground, light.colors.foreground);
220 }
221}