Mirrors
/
helix
mirror of https://github.com/helix-editor/helix
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

Refactor statusline elements to build `Spans` (#9122)

Browse Source 
* Refactor statusline elements to return Spans

* Split render fn to build Spans and blit to Surface
pull/9943/head
Szabin 2 months ago committed by GitHub
parent 427dd2f383
commit bcf7b26393
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 155 additions and 242 deletions
Show Stats Download Patch File Download Diff File

397
helix-term/src/ui/statusline.rs
Unescape Escape View File

@ -4,7 +4,6 @@ use helix_view::document::DEFAULT_LANGUAGE_NAME;
use helix_view::{ use helix_view::{
document::{Mode, SCRATCH_BUFFER_NAME}, document::{Mode, SCRATCH_BUFFER_NAME},
graphics::Rect, graphics::Rect,
theme::Style,
Document, Editor, View, Document, Editor, View,
}; };
@ -20,7 +19,6 @@ pub struct RenderContext<'a> {
pub view: &'a View, pub view: &'a View,
pub focused: bool, pub focused: bool,
pub spinners: &'a ProgressSpinners, pub spinners: &'a ProgressSpinners,
pub parts: RenderBuffer<'a>,
} }
impl<'a> RenderContext<'a> { impl<'a> RenderContext<'a> {
@ -37,18 +35,10 @@ impl<'a> RenderContext<'a> {
view, view,
focused, focused,
spinners, spinners,
parts: RenderBuffer::default(),
} }
} }
} }
#[derive(Default)]
pub struct RenderBuffer<'a> {
pub left: Spans<'a>,
pub center: Spans<'a>,
pub right: Spans<'a>,
}
pub fn render(context: &mut RenderContext, viewport: Rect, surface: &mut Surface) { pub fn render(context: &mut RenderContext, viewport: Rect, surface: &mut Surface) {
let base_style = if context.focused { let base_style = if context.focused {
context.editor.theme.get("ui.statusline") context.editor.theme.get("ui.statusline")
@ -58,85 +48,72 @@ pub fn render(context: &mut RenderContext, viewport: Rect, surface: &mut Surface
surface.set_style(viewport.with_height(1), base_style); surface.set_style(viewport.with_height(1), base_style);
let write_left = |context: &mut RenderContext, text, style| { let statusline = render_statusline(context, viewport.width as usize);
append(&mut context.parts.left, text, &base_style, style)
};
let write_center = |context: &mut RenderContext, text, style| {
append(&mut context.parts.center, text, &base_style, style)
};
let write_right = |context: &mut RenderContext, text, style| {
append(&mut context.parts.right, text, &base_style, style)
};
// Left side of the status line.
let config = context.editor.config();
let element_ids = &config.statusline.left;
element_ids
.iter()
.map(|element_id| get_render_function(*element_id))
.for_each(|render| render(context, write_left));
surface.set_spans( surface.set_spans(
viewport.x, viewport.x,
viewport.y, viewport.y,
&context.parts.left, &statusline,
context.parts.left.width() as u16, statusline.width() as u16,
); );
}
// Right side of the status line. pub fn render_statusline<'a>(context: &mut RenderContext, width: usize) -> Spans<'a> {
let config = context.editor.config();
let element_ids = &config.statusline.right; let element_ids = &config.statusline.left;
element_ids let mut left = element_ids
.iter() .iter()
.map(|element_id| get_render_function(*element_id)) .map(|element_id| get_render_function(*element_id))
.for_each(|render| render(context, write_right)); .flat_map(|render| render(context).0)
.collect::<Vec<Span>>();
surface.set_spans(
viewport.x
+ viewport
.width
.saturating_sub(context.parts.right.width() as u16),
viewport.y,
&context.parts.right,
context.parts.right.width() as u16,
);
// Center of the status line.
let element_ids = &config.statusline.center; let element_ids = &config.statusline.center;
element_ids let mut center = element_ids
.iter() .iter()
.map(|element_id| get_render_function(*element_id)) .map(|element_id| get_render_function(*element_id))
.for_each(|render| render(context, write_center)); .flat_map(|render| render(context).0)
.collect::<Vec<Span>>();
// Width of the empty space between the left and center area and between the center and right area. let element_ids = &config.statusline.right;
let spacing = 1u16; let mut right = element_ids
.iter()
let edge_width = context.parts.left.width().max(context.parts.right.width()) as u16; .map(|element_id| get_render_function(*element_id))
let center_max_width = viewport.width.saturating_sub(2 * edge_width + 2 * spacing); .flat_map(|render| render(context).0)
let center_width = center_max_width.min(context.parts.center.width() as u16); .collect::<Vec<Span>>();
surface.set_spans( let left_area_width: usize = left.iter().map(|s| s.width()).sum();
viewport.x + viewport.width / 2 - center_width / 2, let center_area_width: usize = center.iter().map(|s| s.width()).sum();
viewport.y, let right_area_width: usize = right.iter().map(|s| s.width()).sum();
&context.parts.center,
center_width, let min_spacing_between_areas = 1usize;
); let sides_space_required = left_area_width + right_area_width + min_spacing_between_areas;
} let total_space_required = sides_space_required + center_area_width + min_spacing_between_areas;
let mut statusline: Vec<Span> = vec![];
if center_area_width > 0 && total_space_required <= width {
let center_margin = (width - center_area_width) / 2;
statusline.append(&mut left);
statusline.push(" ".repeat(center_margin - left_area_width).into());
statusline.append(&mut center);
statusline.push(" ".repeat(center_margin - right_area_width).into());
statusline.append(&mut right);
} else if right_area_width > 0 && sides_space_required <= width {
let side_areas_width = left_area_width + right_area_width;
statusline.append(&mut left);
statusline.push(" ".repeat(width - side_areas_width).into());
statusline.append(&mut right);
} else if left_area_width <= width {
statusline.append(&mut left);
}
fn append(buffer: &mut Spans, text: String, base_style: &Style, style: Option<Style>) { statusline.into()
buffer.0.push(Span::styled(
text,
style.map_or(*base_style, |s| (*base_style).patch(s)),
));
} }
fn get_render_function<F>(element_id: StatusLineElementID) -> impl Fn(&mut RenderContext, F) fn get_render_function<'a>(
where element_id: StatusLineElementID,
F: Fn(&mut RenderContext, String, Option<Style>) + Copy, ) -> impl Fn(&RenderContext) -> Spans<'a> {
{
match element_id { match element_id {
helix_view::editor::StatusLineElement::Mode => render_mode, helix_view::editor::StatusLineElement::Mode => render_mode,
helix_view::editor::StatusLineElement::Spinner => render_lsp_spinner, helix_view::editor::StatusLineElement::Spinner => render_lsp_spinner,
@ -166,48 +143,40 @@ where
} }
} }
fn render_mode<F>(context: &mut RenderContext, write: F) fn render_mode<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let visible = context.focused; let visible = context.focused;
let config = context.editor.config(); let config = context.editor.config();
let modenames = &config.statusline.mode; let modenames = &config.statusline.mode;
write( let modename = if visible {
context, match context.editor.mode() {
format!( Mode::Insert => modenames.insert.clone(),
" {} ", Mode::Select => modenames.select.clone(),
if visible { Mode::Normal => modenames.normal.clone(),
match context.editor.mode() { }
Mode::Insert => &modenames.insert, } else {
Mode::Select => &modenames.select, // If not focused, explicitly leave an empty space.
Mode::Normal => &modenames.normal, " ".into()
} };
} else { let modename = format!(" {} ", modename);
// If not focused, explicitly leave an empty space instead of returning None. if config.color_modes {
" " Span::styled(
} modename,
),
if visible && config.color_modes {
match context.editor.mode() { match context.editor.mode() {
Mode::Insert => Some(context.editor.theme.get("ui.statusline.insert")), Mode::Insert => context.editor.theme.get("ui.statusline.insert"),
Mode::Select => Some(context.editor.theme.get("ui.statusline.select")), Mode::Select => context.editor.theme.get("ui.statusline.select"),
Mode::Normal => Some(context.editor.theme.get("ui.statusline.normal")), Mode::Normal => context.editor.theme.get("ui.statusline.normal"),
} },
} else { )
None .into()
}, } else {
); Span::raw(modename).into()
}
} }
// TODO think about handling multiple language servers // TODO think about handling multiple language servers
fn render_lsp_spinner<F>(context: &mut RenderContext, write: F) fn render_lsp_spinner<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let language_server = context.doc.language_servers().next(); let language_server = context.doc.language_servers().next();
write( Span::raw(
context,
language_server language_server
.and_then(|srv| { .and_then(|srv| {
context context
@ -218,14 +187,11 @@ where
// Even if there's no spinner; reserve its space to avoid elements frequently shifting. // Even if there's no spinner; reserve its space to avoid elements frequently shifting.
.unwrap_or(" ") .unwrap_or(" ")
.to_string(), .to_string(),
None, )
); .into()
} }
fn render_diagnostics<F>(context: &mut RenderContext, write: F) fn render_diagnostics<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let (warnings, errors) = context let (warnings, errors) = context
.doc .doc
.diagnostics() .diagnostics()
@ -240,29 +206,28 @@ where
counts counts
}); });
let mut output = Spans::default();
if warnings > 0 { if warnings > 0 {
write( output.0.push(Span::styled(
context,
"●".to_string(), "●".to_string(),
Some(context.editor.theme.get("warning")), context.editor.theme.get("warning"),
); ));
write(context, format!(" {} ", warnings), None); output.0.push(Span::raw(format!(" {} ", warnings)));
} }
if errors > 0 { if errors > 0 {
write( output.0.push(Span::styled(
context,
"●".to_string(), "●".to_string(),
Some(context.editor.theme.get("error")), context.editor.theme.get("error"),
); ));
write(context, format!(" {} ", errors), None); output.0.push(Span::raw(format!(" {} ", errors)));
} }
output
} }
fn render_workspace_diagnostics<F>(context: &mut RenderContext, write: F) fn render_workspace_diagnostics<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let (warnings, errors) = let (warnings, errors) =
context context
.editor .editor
@ -278,51 +243,49 @@ where
counts counts
}); });
let mut output = Spans::default();
if warnings > 0 || errors > 0 { if warnings > 0 || errors > 0 {
write(context, " W ".into(), None); output.0.push(Span::raw(" W "));
} }
if warnings > 0 { if warnings > 0 {
write( output.0.push(Span::styled(
context,
"●".to_string(), "●".to_string(),
Some(context.editor.theme.get("warning")), context.editor.theme.get("warning"),
); ));
write(context, format!(" {} ", warnings), None); output.0.push(Span::raw(format!(" {} ", warnings)));
} }
if errors > 0 { if errors > 0 {
write( output.0.push(Span::styled(
context,
"●".to_string(), "●".to_string(),
Some(context.editor.theme.get("error")), context.editor.theme.get("error"),
); ));
write(context, format!(" {} ", errors), None); output.0.push(Span::raw(format!(" {} ", errors)));
} }
output
} }
fn render_selections<F>(context: &mut RenderContext, write: F) fn render_selections<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let count = context.doc.selection(context.view.id).len(); let count = context.doc.selection(context.view.id).len();
write( Span::raw(format!(
context, " {} sel{} ",
format!(" {} sel{} ", count, if count == 1 { "" } else { "s" }), count,
None, if count == 1 { "" } else { "s" }
); ))
.into()
} }
fn render_primary_selection_length<F>(context: &mut RenderContext, write: F) fn render_primary_selection_length<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let tot_sel = context.doc.selection(context.view.id).primary().len(); let tot_sel = context.doc.selection(context.view.id).primary().len();
write( Span::raw(format!(
context, " {} char{} ",
format!(" {} char{} ", tot_sel, if tot_sel == 1 { "" } else { "s" }), tot_sel,
None, if tot_sel == 1 { "" } else { "s" }
); ))
.into()
} }
fn get_position(context: &RenderContext) -> Position { fn get_position(context: &RenderContext) -> Position {
@ -336,55 +299,33 @@ fn get_position(context: &RenderContext) -> Position {
) )
} }
fn render_position<F>(context: &mut RenderContext, write: F) fn render_position<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let position = get_position(context); let position = get_position(context);
write( Span::raw(format!(" {}:{} ", position.row + 1, position.col + 1)).into()
context,
format!(" {}:{} ", position.row + 1, position.col + 1),
None,
);
} }
fn render_total_line_numbers<F>(context: &mut RenderContext, write: F) fn render_total_line_numbers<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let total_line_numbers = context.doc.text().len_lines(); let total_line_numbers = context.doc.text().len_lines();
Span::raw(format!(" {} ", total_line_numbers)).into()
write(context, format!(" {} ", total_line_numbers), None);
} }
fn render_position_percentage<F>(context: &mut RenderContext, write: F) fn render_position_percentage<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let position = get_position(context); let position = get_position(context);
let maxrows = context.doc.text().len_lines(); let maxrows = context.doc.text().len_lines();
write( Span::raw(format!("{}%", (position.row + 1) * 100 / maxrows)).into()
context,
format!("{}%", (position.row + 1) * 100 / maxrows),
None,
);
} }
fn render_file_encoding<F>(context: &mut RenderContext, write: F) fn render_file_encoding<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let enc = context.doc.encoding(); let enc = context.doc.encoding();
if enc != encoding::UTF_8 { if enc != encoding::UTF_8 {
write(context, format!(" {} ", enc.name()), None); Span::raw(format!(" {} ", enc.name())).into()
} else {
Spans::default()
} }
} }
fn render_file_line_ending<F>(context: &mut RenderContext, write: F) fn render_file_line_ending<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
use helix_core::LineEnding::*; use helix_core::LineEnding::*;
let line_ending = match context.doc.line_ending { let line_ending = match context.doc.line_ending {
Crlf => "CRLF", Crlf => "CRLF",
@ -403,22 +344,16 @@ where
PS => "PS", // U+2029 -- ParagraphSeparator PS => "PS", // U+2029 -- ParagraphSeparator
}; };
write(context, format!(" {} ", line_ending), None); Span::raw(format!(" {} ", line_ending)).into()
} }
fn render_file_type<F>(context: &mut RenderContext, write: F) fn render_file_type<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let file_type = context.doc.language_name().unwrap_or(DEFAULT_LANGUAGE_NAME); let file_type = context.doc.language_name().unwrap_or(DEFAULT_LANGUAGE_NAME);
write(context, format!(" {} ", file_type), None); Span::raw(format!(" {} ", file_type)).into()
} }
fn render_file_name<F>(context: &mut RenderContext, write: F) fn render_file_name<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let title = { let title = {
let rel_path = context.doc.relative_path(); let rel_path = context.doc.relative_path();
let path = rel_path let path = rel_path
@ -428,13 +363,10 @@ where
format!(" {} ", path) format!(" {} ", path)
}; };
write(context, title, None); Span::raw(title).into()
} }
fn render_file_absolute_path<F>(context: &mut RenderContext, write: F) fn render_file_absolute_path<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let title = { let title = {
let path = context.doc.path(); let path = context.doc.path();
let path = path let path = path
@ -444,13 +376,10 @@ where
format!(" {} ", path) format!(" {} ", path)
}; };
write(context, title, None); Span::raw(title).into()
} }
fn render_file_modification_indicator<F>(context: &mut RenderContext, write: F) fn render_file_modification_indicator<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let title = (if context.doc.is_modified() { let title = (if context.doc.is_modified() {
"[+]" "[+]"
} else { } else {
@ -458,26 +387,20 @@ where
}) })
.to_string(); .to_string();
write(context, title, None); Span::raw(title).into()
} }
fn render_read_only_indicator<F>(context: &mut RenderContext, write: F) fn render_read_only_indicator<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let title = if context.doc.readonly { let title = if context.doc.readonly {
" [readonly] " " [readonly] "
} else { } else {
"" ""
} }
.to_string(); .to_string();
write(context, title, None); Span::raw(title).into()
} }
fn render_file_base_name<F>(context: &mut RenderContext, write: F) fn render_file_base_name<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let title = { let title = {
let rel_path = context.doc.relative_path(); let rel_path = context.doc.relative_path();
let path = rel_path let path = rel_path
@ -487,47 +410,37 @@ where
format!(" {} ", path) format!(" {} ", path)
}; };
write(context, title, None); Span::raw(title).into()
} }
fn render_separator<F>(context: &mut RenderContext, write: F) fn render_separator<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let sep = &context.editor.config().statusline.separator; let sep = &context.editor.config().statusline.separator;
write( Span::styled(
context,
sep.to_string(), sep.to_string(),
Some(context.editor.theme.get("ui.statusline.separator")), context.editor.theme.get("ui.statusline.separator"),
); )
.into()
} }
fn render_spacer<F>(context: &mut RenderContext, write: F) fn render_spacer<'a>(_context: &RenderContext) -> Spans<'a> {
where Span::raw(" ").into()
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
write(context, String::from(" "), None);
} }
fn render_version_control<F>(context: &mut RenderContext, write: F) fn render_version_control<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let head = context let head = context
.doc .doc
.version_control_head() .version_control_head()
.unwrap_or_default() .unwrap_or_default()
.to_string(); .to_string();
write(context, head, None); Span::raw(head).into()
} }
fn render_register<F>(context: &mut RenderContext, write: F) fn render_register<'a>(context: &RenderContext) -> Spans<'a> {
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
if let Some(reg) = context.editor.selected_register { if let Some(reg) = context.editor.selected_register {
write(context, format!(" reg={} ", reg), None) Span::raw(format!(" reg={} ", reg)).into()
} else {
Spans::default()
} }
} }

Write Preview
Loading…
Cancel
Save