@@ -0,0 +1,310 @@
1+use helix_core::{coords_at_pos, encoding};
2+use helix_view::{
3+ document::{Mode, SCRATCH_BUFFER_NAME},
4+ graphics::Rect,
5+ theme::Style,
6+ Document, Editor, View,
7+};
8+
9+use crate::ui::ProgressSpinners;
10+
11+use helix_view::editor::StatusLineElement as StatusLineElementID;
12+use tui::buffer::Buffer as Surface;
13+use tui::text::{Span, Spans};
14+
15+pub struct RenderContext<'a> {
16+ pub editor: &'a Editor,
17+ pub doc: &'a Document,
18+ pub view: &'a View,
19+ pub focused: bool,
20+ pub spinners: &'a ProgressSpinners,
21+ pub parts: RenderBuffer<'a>,
22+}
23+
24+impl<'a> RenderContext<'a> {
25+ pub fn new(
26+ editor: &'a Editor,
27+ doc: &'a Document,
28+ view: &'a View,
29+ focused: bool,
30+ spinners: &'a ProgressSpinners,
31+ ) -> Self {
32+ RenderContext {
33+ editor,
34+ doc,
35+ view,
36+ focused,
37+ spinners,
38+ parts: RenderBuffer::default(),
39+ }
40+ }
41+}
42+
43+#[derive(Default)]
44+pub struct RenderBuffer<'a> {
45+ pub left: Spans<'a>,
46+ pub center: Spans<'a>,
47+ pub right: Spans<'a>,
48+}
49+
50+pub fn render(context: &mut RenderContext, viewport: Rect, surface: &mut Surface) {
51+ let base_style = if context.focused {
52+ context.editor.theme.get("ui.statusline")
53+ } else {
54+ context.editor.theme.get("ui.statusline.inactive")
55+ };
56+
57+ surface.set_style(viewport.with_height(1), base_style);
58+
59+ let write_left = |context: &mut RenderContext, text, style| {
60+ append(&mut context.parts.left, text, &base_style, style)
61+ };
62+ let write_center = |context: &mut RenderContext, text, style| {
63+ append(&mut context.parts.center, text, &base_style, style)
64+ };
65+ let write_right = |context: &mut RenderContext, text, style| {
66+ append(&mut context.parts.right, text, &base_style, style)
67+ };
68+
69+ // Left side of the status line.
70+
71+ let element_ids = &context.editor.config().statusline.left;
72+ element_ids
73+ .iter()
74+ .map(|element_id| get_render_function(*element_id))
75+ .for_each(|render| render(context, write_left));
76+
77+ surface.set_spans(
78+ viewport.x,
79+ viewport.y,
80+ &context.parts.left,
81+ context.parts.left.width() as u16,
82+ );
83+
84+ // Right side of the status line.
85+
86+ let element_ids = &context.editor.config().statusline.right;
87+ element_ids
88+ .iter()
89+ .map(|element_id| get_render_function(*element_id))
90+ .for_each(|render| render(context, write_right));
91+
92+ surface.set_spans(
93+ viewport.x
94+ + viewport
95+ .width
96+ .saturating_sub(context.parts.right.width() as u16),
97+ viewport.y,
98+ &context.parts.right,
99+ context.parts.right.width() as u16,
100+ );
101+
102+ // Center of the status line.
103+
104+ let element_ids = &context.editor.config().statusline.center;
105+ element_ids
106+ .iter()
107+ .map(|element_id| get_render_function(*element_id))
108+ .for_each(|render| render(context, write_center));
109+
110+ // Width of the empty space between the left and center area and between the center and right area.
111+ let spacing = 1u16;
112+
113+ let edge_width = context.parts.left.width().max(context.parts.right.width()) as u16;
114+ let center_max_width = viewport.width.saturating_sub(2 * edge_width + 2 * spacing);
115+ let center_width = center_max_width.min(context.parts.center.width() as u16);
116+
117+ surface.set_spans(
118+ viewport.x + viewport.width / 2 - center_width / 2,
119+ viewport.y,
120+ &context.parts.center,
121+ center_width,
122+ );
123+}
124+
125+fn append(buffer: &mut Spans, text: String, base_style: &Style, style: Option<Style>) {
126+ buffer.0.push(Span::styled(
127+ text,
128+ style.map_or(*base_style, |s| (*base_style).patch(s)),
129+ ));
130+}
131+
132+fn get_render_function<F>(element_id: StatusLineElementID) -> impl Fn(&mut RenderContext, F)
133+where
134+ F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
135+{
136+ match element_id {
137+ helix_view::editor::StatusLineElement::Mode => render_mode,
138+ helix_view::editor::StatusLineElement::Spinner => render_lsp_spinner,
139+ helix_view::editor::StatusLineElement::FileName => render_file_name,
140+ helix_view::editor::StatusLineElement::FileEncoding => render_file_encoding,
141+ helix_view::editor::StatusLineElement::FileType => render_file_type,
142+ helix_view::editor::StatusLineElement::Diagnostics => render_diagnostics,
143+ helix_view::editor::StatusLineElement::Selections => render_selections,
144+ helix_view::editor::StatusLineElement::Position => render_position,
145+ }
146+}
147+
148+fn render_mode<F>(context: &mut RenderContext, write: F)
149+where
150+ F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
151+{
152+ let visible = context.focused;
153+
154+ write(
155+ context,
156+ format!(
157+ " {} ",
158+ if visible {
159+ match context.doc.mode() {
160+ Mode::Insert => "INS",
161+ Mode::Select => "SEL",
162+ Mode::Normal => "NOR",
163+ }
164+ } else {
165+ // If not focused, explicitly leave an empty space instead of returning None.
166+ " "
167+ }
168+ ),
169+ if visible && context.editor.config().color_modes {
170+ match context.doc.mode() {
171+ Mode::Insert => Some(context.editor.theme.get("ui.statusline.insert")),
172+ Mode::Select => Some(context.editor.theme.get("ui.statusline.select")),
173+ Mode::Normal => Some(context.editor.theme.get("ui.statusline.normal")),
174+ }
175+ } else {
176+ None
177+ },
178+ );
179+}
180+
181+fn render_lsp_spinner<F>(context: &mut RenderContext, write: F)
182+where
183+ F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
184+{
185+ write(
186+ context,
187+ context
188+ .doc
189+ .language_server()
190+ .and_then(|srv| {
191+ context
192+ .spinners
193+ .get(srv.id())
194+ .and_then(|spinner| spinner.frame())
195+ })
196+ // Even if there's no spinner; reserve its space to avoid elements frequently shifting.
197+ .unwrap_or(" ")
198+ .to_string(),
199+ None,
200+ );
201+}
202+
203+fn render_diagnostics<F>(context: &mut RenderContext, write: F)
204+where
205+ F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
206+{
207+ let (warnings, errors) = context
208+ .doc
209+ .diagnostics()
210+ .iter()
211+ .fold((0, 0), |mut counts, diag| {
212+ use helix_core::diagnostic::Severity;
213+ match diag.severity {
214+ Some(Severity::Warning) => counts.0 += 1,
215+ Some(Severity::Error) | None => counts.1 += 1,
216+ _ => {}
217+ }
218+ counts
219+ });
220+
221+ if warnings > 0 {
222+ write(
223+ context,
224+ "●".to_string(),
225+ Some(context.editor.theme.get("warning")),
226+ );
227+ write(context, format!(" {} ", warnings), None);
228+ }
229+
230+ if errors > 0 {
231+ write(
232+ context,
233+ "●".to_string(),
234+ Some(context.editor.theme.get("error")),
235+ );
236+ write(context, format!(" {} ", errors), None);
237+ }
238+}
239+
240+fn render_selections<F>(context: &mut RenderContext, write: F)
241+where
242+ F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
243+{
244+ let count = context.doc.selection(context.view.id).len();
245+ write(
246+ context,
247+ format!(" {} sel{} ", count, if count == 1 { "" } else { "s" }),
248+ None,
249+ );
250+}
251+
252+fn render_position<F>(context: &mut RenderContext, write: F)
253+where
254+ F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
255+{
256+ let position = coords_at_pos(
257+ context.doc.text().slice(..),
258+ context
259+ .doc
260+ .selection(context.view.id)
261+ .primary()
262+ .cursor(context.doc.text().slice(..)),
263+ );
264+
265+ write(
266+ context,
267+ format!(" {}:{} ", position.row + 1, position.col + 1),
268+ None,
269+ );
270+}
271+
272+fn render_file_encoding<F>(context: &mut RenderContext, write: F)
273+where
274+ F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
275+{
276+ let enc = context.doc.encoding();
277+
278+ if enc != encoding::UTF_8 {
279+ write(context, format!(" {} ", enc.name()), None);
280+ }
281+}
282+
283+fn render_file_type<F>(context: &mut RenderContext, write: F)
284+where
285+ F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
286+{
287+ let file_type = context.doc.language_id().unwrap_or("text");
288+
289+ write(context, format!(" {} ", file_type), None);
290+}
291+
292+fn render_file_name<F>(context: &mut RenderContext, write: F)
293+where
294+ F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
295+{
296+ let title = {
297+ let rel_path = context.doc.relative_path();
298+ let path = rel_path
299+ .as_ref()
300+ .map(|p| p.to_string_lossy())
301+ .unwrap_or_else(|| SCRATCH_BUFFER_NAME.into());
302+ format!(
303+ " {}{} ",
304+ path,
305+ if context.doc.is_modified() { "[+]" } else { "" }
306+ )
307+ };
308+
309+ write(context, title, None);
310+}