mirrors/helix
1
0
Fork 0
mirror of https://github.com/helix-editor/helix.git synced 2025-04-03 10:57:48 +03:00
Code Issues Projects Releases Packages Wiki Activity

feat: add support for basic icons

Browse source
This commit is contained in:
Rolo 2024-12-30 04:57:13 -08:00
parent 0ee5850016
commit 578a81f146
13 changed files with 831 additions and 40 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Cargo.lock generated
View file

@ -1560,6 +1560,7 @@ dependencies = [
"serde",
"serde_json",
"slotmap",
"smartstring",
"tempfile",
"thiserror 2.0.12",
"tokio",
@ -2423,6 +2424,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3fb72c633efbaa2dd666986505016c32c3044395ceaf881518399d2f4127ee29"
dependencies = [
"autocfg",
"serde",
"static_assertions",
"version_check",
]

27
helix-term/src/commands.rs
View file

@ -44,6 +44,7 @@ use helix_core::{
use helix_view::{
document::{FormatterError, Mode, SCRATCH_BUFFER_NAME},
editor::Action,
icons::ICONS,
info::Info,
input::KeyEvent,
keyboard::KeyCode,
@ -3296,12 +3297,28 @@ fn changed_file_picker(cx: &mut Context) {
let columns = [
PickerColumn::new("change", |change: &FileChange, data: &FileChangeData| {
let icons = ICONS.load();
match change {
FileChange::Untracked { .. } => Span::styled("+ untracked", data.style_untracked),
FileChange::Modified { .. } => Span::styled("~ modified", data.style_modified),
FileChange::Conflict { .. } => Span::styled("x conflict", data.style_conflict),
FileChange::Deleted { .. } => Span::styled("- deleted", data.style_deleted),
FileChange::Renamed { .. } => Span::styled("> renamed", data.style_renamed),
FileChange::Untracked { .. } => Span::styled(
format!("{} untracked", icons.vcs().added()),
data.style_untracked,
),
FileChange::Modified { .. } => Span::styled(
format!("{} modified", icons.vcs().modified()),
data.style_modified,
),
FileChange::Conflict { .. } => Span::styled(
format!("{} conflict", icons.vcs().conflict()),
data.style_conflict,
),
FileChange::Deleted { .. } => Span::styled(
format!("{} deleted", icons.vcs().removed()),
data.style_deleted,
),
FileChange::Renamed { .. } => Span::styled(
format!("{} renamed", icons.vcs().renamed()),
data.style_renamed,
),
}
.into()
}),

34
helix-term/src/commands/lsp.rs
View file

@ -22,6 +22,7 @@ use helix_view::{
document::{DocumentInlayHints, DocumentInlayHintsId},
editor::Action,
handlers::lsp::SignatureHelpInvoked,
icons::ICONS,
theme::Style,
Document, View,
};
@ -242,11 +243,22 @@ fn diag_picker(
ui::PickerColumn::new(
"severity",
|item: &PickerDiagnostic, styles: &DiagnosticStyles| {
let icons = ICONS.load();
match item.diag.severity {
Some(DiagnosticSeverity::HINT) => Span::styled("HINT", styles.hint),
Some(DiagnosticSeverity::INFORMATION) => Span::styled("INFO", styles.info),
Some(DiagnosticSeverity::WARNING) => Span::styled("WARN", styles.warning),
Some(DiagnosticSeverity::ERROR) => Span::styled("ERROR", styles.error),
Some(DiagnosticSeverity::HINT) => {
Span::styled(format!("{} HINT", icons.diagnostic().hint()), styles.hint)
}
Some(DiagnosticSeverity::INFORMATION) => {
Span::styled(format!("{} INFO", icons.diagnostic().info()), styles.info)
}
Some(DiagnosticSeverity::WARNING) => Span::styled(
format!("{} WARN", icons.diagnostic().warning()),
styles.warning,
),
Some(DiagnosticSeverity::ERROR) => Span::styled(
format!("{} ERROR", icons.diagnostic().error()),
styles.error,
),
_ => Span::raw(""),
}
.into()
@ -397,7 +409,12 @@ pub fn symbol_picker(cx: &mut Context) {
let call = move |_editor: &mut Editor, compositor: &mut Compositor| {
let columns = [
ui::PickerColumn::new("kind", |item: &SymbolInformationItem, _| {
display_symbol_kind(item.symbol.kind).into()
let icons = ICONS.load();
let name = display_symbol_kind(item.symbol.kind);
icons
.lsp()
.get(name)
.map_or_else(|| name.into(), |symbol| format!("{symbol} {name}").into())
}),
// Some symbols in the document symbol picker may have a URI that isn't
// the current file. It should be rare though, so we concatenate that
@ -515,7 +532,12 @@ pub fn workspace_symbol_picker(cx: &mut Context) {
};
let columns = [
ui::PickerColumn::new("kind", |item: &SymbolInformationItem, _| {
display_symbol_kind(item.symbol.kind).into()
let icons = ICONS.load();
let name = display_symbol_kind(item.symbol.kind);
icons
.lsp()
.get(name)
.map_or_else(|| name.into(), |symbol| format!("{symbol} {name}").into())
}),
ui::PickerColumn::new("name", |item: &SymbolInformationItem, _| {
item.symbol.name.as_str().into()

24
helix-term/src/config.rs
View file

@ -2,11 +2,13 @@ use crate::keymap;
use crate::keymap::{merge_keys, KeyTrie};
use helix_loader::merge_toml_values;
use helix_view::document::Mode;
use helix_view::icons::{Icons, ICONS};
use serde::Deserialize;
use std::collections::HashMap;
use std::fmt::Display;
use std::fs;
use std::io::Error as IOError;
use std::sync::Arc;
use toml::de::Error as TomlError;
#[derive(Debug, Clone, PartialEq)]
@ -22,6 +24,7 @@ pub struct ConfigRaw {
pub theme: Option<String>,
pub keys: Option<HashMap<Mode, KeyTrie>>,
pub editor: Option<toml::Value>,
pub icons: Option<toml::Value>,
}
impl Default for Config {
@ -64,6 +67,7 @@ impl Config {
global.and_then(|file| toml::from_str(&file).map_err(ConfigLoadError::BadConfig));
let local_config: Result<ConfigRaw, ConfigLoadError> =
local.and_then(|file| toml::from_str(&file).map_err(ConfigLoadError::BadConfig));
let res = match (global_config, local_config) {
(Ok(global), Ok(local)) => {
let mut keys = keymap::default();
@ -84,6 +88,18 @@ impl Config {
.map_err(ConfigLoadError::BadConfig)?,
};
let icons: Icons = match (global.icons, local.icons) {
(None, None) => Icons::default(),
(None, Some(val)) | (Some(val), None) => {
val.try_into().map_err(ConfigLoadError::BadConfig)?
}
(Some(global), Some(local)) => merge_toml_values(global, local, 3)
.try_into()
.map_err(ConfigLoadError::BadConfig)?,
};
ICONS.store(Arc::new(icons));
Config {
theme: local.theme.or(global.theme),
keys,
@ -100,6 +116,14 @@ impl Config {
if let Some(keymap) = config.keys {
merge_keys(&mut keys, keymap);
}
let icons = config.icons.map_or_else(
|| Ok(Icons::default()),
|val| val.try_into().map_err(ConfigLoadError::BadConfig),
)?;
ICONS.store(Arc::new(icons));
Config {
theme: config.theme,
keys,

5
helix-term/src/handlers/document_colors.rs
View file

@ -8,6 +8,7 @@ use helix_view::{
document::DocumentColorSwatches,
events::{DocumentDidChange, DocumentDidOpen, LanguageServerExited, LanguageServerInitialized},
handlers::{lsp::DocumentColorsEvent, Handlers},
icons::ICONS,
DocumentId, Editor, Theme,
};
use tokio::time::Instant;
@ -120,9 +121,11 @@ fn attach_document_colors(
let mut color_swatches_padding = Vec::with_capacity(doc_colors.len());
let mut colors = Vec::with_capacity(doc_colors.len());
let icons = ICONS.load();
for (pos, color) in doc_colors {
color_swatches_padding.push(InlineAnnotation::new(pos, " "));
color_swatches.push(InlineAnnotation::new(pos, "■"));
color_swatches.push(InlineAnnotation::new(pos, icons.lsp().color()));
colors.push(Theme::rgb_highlight(
(color.red * 255.) as u8,
(color.green * 255.) as u8,

16
helix-term/src/ui/completion.rs
View file

@ -9,6 +9,7 @@ use crate::{
use helix_core::snippets::{ActiveSnippet, RenderedSnippet, Snippet};
use helix_core::{self as core, chars, fuzzy::MATCHER, Change, Transaction};
use helix_lsp::{lsp, util, OffsetEncoding};
use helix_view::icons::ICONS;
use helix_view::{
editor::CompleteAction,
handlers::lsp::SignatureHelpInvoked,
@ -45,7 +46,7 @@ impl menu::Item for CompletionItem {
CompletionItem::Other(core::CompletionItem { label, .. }) => label,
};
let kind = match self {
let mut kind = match self {
CompletionItem::Lsp(LspCompletionItem { item, .. }) => match item.kind {
Some(lsp::CompletionItemKind::TEXT) => "text".into(),
Some(lsp::CompletionItemKind::METHOD) => "method".into(),
@ -78,9 +79,13 @@ impl menu::Item for CompletionItem {
})
.and_then(Color::from_hex)
.map_or("color".into(), |color| {
let icons = ICONS.load();
Spans::from(vec![
Span::raw("color "),
Span::styled("■", Style::default().fg(color)),
Span::styled(
icons.lsp().color().to_string(),
Style::default().fg(color),
),
])
}),
Some(lsp::CompletionItemKind::FILE) => "file".into(),
@ -101,6 +106,13 @@ impl menu::Item for CompletionItem {
CompletionItem::Other(core::CompletionItem { kind, .. }) => kind.as_ref().into(),
};
let icons = ICONS.load();
let name = &kind.0[0].content;
if let Some(icon) = icons.lsp().get(name) {
kind.0[0].content = format!("{icon} {name}").into();
}
let label = Span::styled(
label,
if deprecated {

19
helix-term/src/ui/editor.rs
View file

@ -24,9 +24,10 @@ use helix_core::{
};
use helix_view::{
annotations::diagnostics::DiagnosticFilter,
document::{Mode, SCRATCH_BUFFER_NAME},
document::{Mode, DEFAULT_LANGUAGE_NAME, SCRATCH_BUFFER_NAME},
editor::{CompleteAction, CursorShapeConfig},
graphics::{Color, CursorKind, Modifier, Rect, Style},
icons::ICONS,
input::{KeyEvent, MouseButton, MouseEvent, MouseEventKind},
keyboard::{KeyCode, KeyModifiers},
Document, Editor, Theme, View,
@ -647,7 +648,21 @@ impl EditorView {
bufferline_inactive
};
let text = format!(" {}{} ", fname, if doc.is_modified() { "[+]" } else { "" });
let lang = doc.language_name().unwrap_or(DEFAULT_LANGUAGE_NAME);
let icons = ICONS.load();
let icon = icons.mime().get(lang);
let text = if lang == icon {
format!(" {} {}", fname, if doc.is_modified() { "[+] " } else { "" })
} else {
format!(
" {icon} {} {}",
fname,
if doc.is_modified() { "[+] " } else { "" }
)
};
let used_width = viewport.x.saturating_sub(x);
let rem_width = surface.area.width.saturating_sub(used_width);

38
helix-term/src/ui/statusline.rs
View file

@ -1,6 +1,7 @@
use helix_core::{coords_at_pos, encoding, Position};
use helix_lsp::lsp::DiagnosticSeverity;
use helix_view::document::DEFAULT_LANGUAGE_NAME;
use helix_view::icons::ICONS;
use helix_view::{
document::{Mode, SCRATCH_BUFFER_NAME},
graphics::Rect,
@ -240,10 +241,12 @@ where
counts
});
let icons = ICONS.load();
if warnings > 0 {
write(
context,
"●".to_string(),
icons.diagnostic().warning().to_string(),
Some(context.editor.theme.get("warning")),
);
write(context, format!(" {} ", warnings), None);
@ -252,7 +255,7 @@ where
if errors > 0 {
write(
context,
"●".to_string(),
icons.diagnostic().error().to_string(),
Some(context.editor.theme.get("error")),
);
write(context, format!(" {} ", errors), None);
@ -282,10 +285,12 @@ where
write(context, " W ".into(), None);
}
let icons = ICONS.load();
if warnings > 0 {
write(
context,
"●".to_string(),
icons.diagnostic().warning().to_string(),
Some(context.editor.theme.get("warning")),
);
write(context, format!(" {} ", warnings), None);
@ -294,7 +299,7 @@ where
if errors > 0 {
write(
context,
"●".to_string(),
icons.diagnostic().error().to_string(),
Some(context.editor.theme.get("error")),
);
write(context, format!(" {} ", errors), None);
@ -410,9 +415,13 @@ fn render_file_type<F>(context: &mut RenderContext, write: F)
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let file_type = context.doc.language_name().unwrap_or(DEFAULT_LANGUAGE_NAME);
let icons = ICONS.load();
write(context, format!(" {} ", file_type), None);
let icon = icons
.mime()
.get(context.doc.language_name().unwrap_or(DEFAULT_LANGUAGE_NAME));
write(context, format!(" {} ", icon), None);
}
fn render_file_name<F>(context: &mut RenderContext, write: F)
@ -514,13 +523,18 @@ fn render_version_control<F>(context: &mut RenderContext, write: F)
where
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
{
let head = context
.doc
.version_control_head()
.unwrap_or_default()
.to_string();
let head = context.doc.version_control_head().unwrap_or_default();
write(context, head, None);
let icons = ICONS.load();
let icon = icons.vcs().icon();
let vcs = if head.is_empty() {
format!("{head}")
} else {
format!("{icon} {head}")
};
write(context, vcs, None);
}
fn render_register<F>(context: &mut RenderContext, write: F)

19
helix-term/src/ui/text_decorations/diagnostics.rs
View file

@ -9,6 +9,7 @@ use helix_view::annotations::diagnostics::{
DiagnosticFilter, InlineDiagnosticAccumulator, InlineDiagnosticsConfig,
};
use helix_view::icons::ICONS;
use helix_view::theme::Style;
use helix_view::{Document, Theme};
@ -102,6 +103,24 @@ impl Renderer<'_, '_> {
let mut end_col = start_col;
let mut draw_col = (col + 1) as u16;
// Draw the diagnostic indicator:
if !self.renderer.column_in_bounds(draw_col as usize, 2) {
return 0;
}
let icons = ICONS.load();
let symbol = match diag.severity() {
Severity::Hint => icons.diagnostic().hint(),
Severity::Info => icons.diagnostic().info(),
Severity::Warning => icons.diagnostic().warning(),
Severity::Error => icons.diagnostic().error(),
};
self.renderer
.set_string(self.renderer.viewport.x + draw_col, row, symbol, style);
draw_col += 2;
for line in diag.message.lines() {
if !self.renderer.column_in_bounds(draw_col as usize, 1) {
break;

2
helix-view/Cargo.toml
View file

@ -52,6 +52,8 @@ log = "~0.4"
parking_lot.workspace = true
thiserror.workspace = true
smartstring = { version = "1.0.1", features = ["serde"]}
[target.'cfg(windows)'.dependencies]
clipboard-win = { version = "5.4", features = ["std"] }

35
helix-view/src/gutter.rs
View file

@ -5,6 +5,7 @@ use helix_core::syntax::LanguageServerFeature;
use crate::{
editor::GutterType,
graphics::{Style, UnderlineStyle},
icons::ICONS,
Document, Editor, Theme, View,
};
@ -46,7 +47,6 @@ impl GutterType {
}
pub fn diagnostic<'doc>(
_editor: &'doc Editor,
doc: &'doc Document,
_view: &View,
theme: &Theme,
@ -74,15 +74,20 @@ pub fn diagnostic<'doc>(
.any(|ls| ls.id() == id)
})
});
diagnostics_on_line.max_by_key(|d| d.severity).map(|d| {
write!(out, "●").ok();
match d.severity {
Some(Severity::Error) => error,
Some(Severity::Warning) | None => warning,
Some(Severity::Info) => info,
Some(Severity::Hint) => hint,
}
})
diagnostics_on_line
.max_by_key(|d| d.severity)
.map(move |d| {
let icons = ICONS.load();
let (style, symbol) = match d.severity {
Some(Severity::Error) => (error, icons.diagnostic().error()),
Some(Severity::Warning) | None => (warning, icons.diagnostic().warning()),
Some(Severity::Info) => (info, icons.diagnostic().info()),
Some(Severity::Hint) => (hint, icons.diagnostic().hint()),
};
out.push_str(symbol);
style
})
},
)
}
@ -264,7 +269,13 @@ pub fn breakpoints<'doc>(
breakpoint_style
};
let sym = if breakpoint.verified { "●" } else { "◯" };
let icons = ICONS.load();
let sym = if breakpoint.verified {
icons.dap().verified()
} else {
icons.dap().unverified()
};
write!(out, "{}", sym).unwrap();
Some(style)
},
@ -313,7 +324,7 @@ pub fn diagnostics_or_breakpoints<'doc>(
theme: &Theme,
is_focused: bool,
) -> GutterFn<'doc> {
let mut diagnostics = diagnostic(editor, doc, view, theme, is_focused);
let mut diagnostics = diagnostic(doc, view, theme, is_focused);
let mut breakpoints = breakpoints(editor, doc, view, theme, is_focused);
let mut execution_pause_indicator = execution_pause_indicator(editor, doc, theme, is_focused);

649
helix-view/src/icons.rs Normal file
View file

@ -0,0 +1,649 @@
use arc_swap::ArcSwap;
use once_cell::sync::Lazy;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use smartstring::{LazyCompact, SmartString};
type String = SmartString<LazyCompact>;
pub static ICONS: Lazy<ArcSwap<Icons>> = Lazy::new(ArcSwap::default);
// TODO: Snippet {enabled, icon  }
// TODO: Text/Spellcheck { enabled, icon 󰓆 }
/// Centralized location for icons that can be used throughout the UI.
#[derive(Debug, Default, Deserialize, PartialEq, Eq, Clone)]
#[serde(default)]
pub struct Icons {
mime: Mime,
lsp: Lsp,
diagnostic: Diagnostic,
vcs: Vcs,
dap: Dap,
}
impl Icons {
#[inline]
pub fn mime(&self) -> &Mime {
&self.mime
}
#[inline]
pub fn lsp(&self) -> &Lsp {
&self.lsp
}
#[inline]
pub fn diagnostic(&self) -> &Diagnostic {
&self.diagnostic
}
#[inline]
pub fn vcs(&self) -> &Vcs {
&self.vcs
}
#[inline]
pub fn dap(&self) -> &Dap {
&self.dap
}
}
// https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_documentSymbol
#[derive(Debug, Serialize, Deserialize, Default, PartialEq, Eq, Clone)]
pub struct Lsp {
enabled: bool,
file: Option<String>,
module: Option<String>,
namespace: Option<String>,
package: Option<String>,
class: Option<String>,
method: Option<String>,
property: Option<String>,
field: Option<String>,
constructor: Option<String>,
#[serde(rename = "enum")]
r#enum: Option<String>,
interface: Option<String>,
function: Option<String>,
variable: Option<String>,
constant: Option<String>,
string: Option<String>,
number: Option<String>,
boolean: Option<String>,
array: Option<String>,
object: Option<String>,
key: Option<String>,
null: Option<String>,
enum_member: Option<String>,
#[serde(rename = "struct")]
r#struct: Option<String>,
event: Option<String>,
operator: Option<String>,
type_parameter: Option<String>,
color: Option<String>,
keyword: Option<String>,
value: Option<String>,
snippet: Option<String>,
}
impl Lsp {
#[inline]
#[must_use]
pub fn get(&self, kind: &str) -> Option<String> {
if !self.enabled {
return None;
}
let symbol = match kind {
"file" => self.file(),
"module" => self.module(),
"namespace" => self.namespace(),
"package" => self.package(),
"class" => self.class(),
"method" => self.method(),
"property" => self.property(),
"field" => self.field(),
"construct" => self.constructor(),
"enum" => self.r#enum(),
"interface" => self.interface(),
"function" => self.function(),
"variable" => self.variable(),
"constant" => self.constant(),
"string" => self.string(),
"number" => self.number(),
"boolean" => self.boolean(),
"array" => self.array(),
"object" => self.object(),
"key" => self.key(),
"null" => self.null(),
"enummem" | "enum_member" => self.enum_member(),
"struct" => self.r#struct(),
"event" => self.event(),
"operator" => self.operator(),
"typeparam" => self.type_parameter(),
"color" => self.color(),
"keyword" => self.keyword(),
"value" => self.value(),
"snippet" => self.snippet(),
_ => return None,
};
Some(String::from(symbol))
}
#[inline]
pub fn file(&self) -> &str {
if self.enabled {
return self.file.as_ref().map_or("", |file| file);
}
""
}
#[inline]
pub fn module(&self) -> &str {
if self.enabled {
return self.module.as_ref().map_or("", |module| module);
}
""
}
#[inline]
pub fn namespace(&self) -> &str {
if self.enabled {
return self.namespace.as_ref().map_or("", |namespace| namespace);
}
""
}
#[inline]
pub fn package(&self) -> &str {
if self.enabled {
return self.package.as_ref().map_or("", |package| package);
}
""
}
#[inline]
pub fn class(&self) -> &str {
if self.enabled {
return self.class.as_ref().map_or("", |class| class);
}
""
}
#[inline]
pub fn method(&self) -> &str {
if self.enabled {
return self.method.as_ref().map_or("", |method| method);
}
""
}
#[inline]
pub fn property(&self) -> &str {
if self.enabled {
return self.property.as_ref().map_or("", |property| property);
}
""
}
#[inline]
pub fn field(&self) -> &str {
if self.enabled {
return self.field.as_ref().map_or("", |field| field);
}
""
}
#[inline]
pub fn constructor(&self) -> &str {
if self.enabled {
return self
.constructor
.as_ref()
.map_or("", |constructor| constructor);
}
""
}
#[inline]
pub fn r#enum(&self) -> &str {
if self.enabled {
return self.r#enum.as_ref().map_or("", |r#enum| r#enum);
}
""
}
#[inline]
pub fn interface(&self) -> &str {
if self.enabled {
return self.interface.as_ref().map_or("", |interface| interface);
}
""
}
#[inline]
pub fn function(&self) -> &str {
if self.enabled {
return self.function.as_ref().map_or("", |function| function);
}
""
}
#[inline]
pub fn variable(&self) -> &str {
if self.enabled {
return self.variable.as_ref().map_or("", |variable| variable);
}
""
}
#[inline]
pub fn constant(&self) -> &str {
if self.enabled {
return self.constant.as_ref().map_or("", |constant| constant);
}
""
}
#[inline]
pub fn string(&self) -> &str {
if self.enabled {
return self.string.as_ref().map_or("", |string| string);
}
""
}
#[inline]
pub fn number(&self) -> &str {
if self.enabled {
return self.number.as_ref().map_or("", |number| number);
}
""
}
#[inline]
pub fn boolean(&self) -> &str {
if self.enabled {
return self.boolean.as_ref().map_or("", |boolean| boolean);
}
""
}
#[inline]
pub fn array(&self) -> &str {
if self.enabled {
return self.array.as_ref().map_or("", |array| array);
}
""
}
#[inline]
pub fn object(&self) -> &str {
if self.enabled {
return self.object.as_ref().map_or("", |object| object);
}
""
}
#[inline]
pub fn key(&self) -> &str {
if self.enabled {
return self.key.as_ref().map_or("", |key| key);
}
""
}
#[inline]
pub fn null(&self) -> &str {
if self.enabled {
return self.null.as_ref().map_or("󰟢", |null| null);
}
""
}
#[inline]
pub fn enum_member(&self) -> &str {
if self.enabled {
return self
.enum_member
.as_ref()
.map_or("", |enum_member| enum_member);
}
""
}
#[inline]
pub fn r#struct(&self) -> &str {
if self.enabled {
return self.r#struct.as_ref().map_or("", |r#struct| r#struct);
}
""
}
#[inline]
pub fn event(&self) -> &str {
if self.enabled {
return self.event.as_ref().map_or("", |event| event);
}
""
}
#[inline]
pub fn operator(&self) -> &str {
if self.enabled {
return self.operator.as_ref().map_or("", |operator| operator);
}
""
}
#[inline]
pub fn type_parameter(&self) -> &str {
if self.enabled {
return self
.type_parameter
.as_ref()
.map_or("", |type_parameter| type_parameter);
}
""
}
#[inline]
pub fn color(&self) -> &str {
if self.enabled {
return self.color.as_ref().map_or("■", |color| color);
}
""
}
#[inline]
pub fn keyword(&self) -> &str {
if self.enabled {
return self.keyword.as_ref().map_or("", |keyword| keyword);
}
""
}
#[inline]
pub fn value(&self) -> &str {
if self.enabled {
return self.value.as_ref().map_or("󰎠", |value| value);
}
""
}
#[inline]
pub fn snippet(&self) -> &str {
if self.enabled {
return self.snippet.as_ref().map_or("", |snippet| snippet);
}
""
}
}
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Default)]
pub struct Diagnostic {
hint: Option<String>,
info: Option<String>,
warning: Option<String>,
error: Option<String>,
}
impl Diagnostic {
#[inline]
pub fn hint(&self) -> &str {
self.hint.as_ref().map_or("○", |hint| hint)
}
#[inline]
pub fn info(&self) -> &str {
self.info.as_ref().map_or("●", |info| info)
}
#[inline]
pub fn warning(&self) -> &str {
self.warning.as_ref().map_or("▲", |warning| warning)
}
#[inline]
pub fn error(&self) -> &str {
self.error.as_ref().map_or("■", |error| error)
}
}
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Default)]
pub struct Vcs {
enabled: bool,
icon: Option<String>,
added: Option<String>,
removed: Option<String>,
ignored: Option<String>,
modified: Option<String>,
renamed: Option<String>,
conflict: Option<String>,
}
impl Vcs {
#[inline]
pub fn icon(&self) -> &str {
if self.enabled {
return self.icon.as_ref().map_or("", |icon| icon.as_str());
}
""
}
#[inline]
pub fn added(&self) -> &str {
if self.enabled {
return self.added.as_ref().map_or("", |added| added.as_str());
}
""
}
#[inline]
pub fn removed(&self) -> &str {
if self.enabled {
return self
.removed
.as_ref()
.map_or("", |removed| removed.as_str());
}
""
}
#[inline]
pub fn ignored(&self) -> &str {
if self.enabled {
return self
.ignored
.as_ref()
.map_or("", |ignored| ignored.as_str());
}
""
}
#[inline]
pub fn modified(&self) -> &str {
if self.enabled {
return self
.modified
.as_ref()
.map_or("", |modified| modified.as_str());
}
""
}
#[inline]
pub fn renamed(&self) -> &str {
if self.enabled {
return self
.renamed
.as_ref()
.map_or("", |renamed| renamed.as_str());
}
""
}
#[inline]
pub fn conflict(&self) -> &str {
if self.enabled {
return self
.conflict
.as_ref()
.map_or("", |conflict| conflict.as_str());
}
""
}
}
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Default)]
pub struct Mime {
enabled: bool,
directory: Option<String>,
#[serde(flatten)]
mime: HashMap<String, String>,
}
static MIMES: once_cell::sync::Lazy<HashMap<String, String>> = once_cell::sync::Lazy::new(|| {
let mut mimes = HashMap::new();
mimes.insert(String::from("rust"), String::from("󱘗"));
mimes.insert(String::from("python"), String::from("󰌠"));
mimes.insert(String::from("c"), String::from(""));
mimes.insert(String::from("cpp"), String::from(""));
mimes.insert(String::from("c-sharp"), String::from("󰌛"));
mimes.insert(String::from("d"), String::from(""));
mimes.insert(String::from("elixir"), String::from(""));
mimes.insert(String::from("fsharp"), String::from(""));
mimes.insert(String::from("go"), String::from("󰟓"));
mimes.insert(String::from("haskell"), String::from("󰲒"));
mimes.insert(String::from("java"), String::from("󰬷"));
mimes.insert(String::from("javascript"), String::from("󰌞"));
mimes.insert(String::from("kotlin"), String::from("󱈙"));
mimes.insert(String::from("html"), String::from("󰌝"));
mimes.insert(String::from("css"), String::from("󰌜"));
mimes.insert(String::from("scss"), String::from("󰌜"));
mimes.insert(String::from("typescript"), String::from("󰛦"));
mimes.insert(String::from("bash"), String::from(""));
mimes.insert(String::from("php"), String::from("󰌟"));
mimes.insert(String::from("powershell"), String::from("󰨊"));
mimes.insert(String::from("dart"), String::from(""));
mimes.insert(String::from("ruby"), String::from("󰴭"));
mimes.insert(String::from("swift"), String::from("󰛥"));
mimes.insert(String::from("r"), String::from("󰟔"));
mimes.insert(String::from("groovy"), String::from(""));
mimes.insert(String::from("scala"), String::from(""));
mimes.insert(String::from("perl"), String::from(""));
mimes.insert(String::from("clojure"), String::from(""));
mimes.insert(String::from("julia"), String::from(""));
mimes.insert(String::from("zig"), String::from(""));
mimes.insert(String::from("fortran"), String::from("󱈚"));
mimes.insert(String::from("erlang"), String::from(""));
mimes.insert(String::from("ocaml"), String::from(""));
mimes.insert(String::from("crystal"), String::from(""));
mimes.insert(String::from("svelte"), String::from(""));
mimes.insert(String::from("gdscript"), String::from(""));
mimes.insert(String::from("nim"), String::from(""));
mimes.insert(String::from("jsx"), String::from(""));
mimes.insert(String::from("tsx"), String::from(""));
mimes.insert(String::from("twig"), String::from(""));
mimes.insert(String::from("lua"), String::from(""));
mimes.insert(String::from("vue"), String::from(""));
mimes.insert(String::from("prolog"), String::from(""));
mimes.insert(String::from("common-lisp"), String::from(""));
mimes.insert(String::from("elm"), String::from(""));
mimes.insert(String::from("rescript"), String::from(""));
mimes.insert(String::from("solidity"), String::from(""));
mimes.insert(String::from("vala"), String::from(""));
mimes.insert(String::from("scheme"), String::from(""));
mimes.insert(String::from("v"), String::from(""));
mimes.insert(String::from("prisma"), String::from(""));
mimes.insert(String::from("ada"), String::from(""));
mimes.insert(String::from("astro"), String::from(""));
mimes.insert(String::from("matlab"), String::from(""));
mimes.insert(String::from("rst"), String::from(""));
mimes.insert(String::from("opencl"), String::from(""));
mimes.insert(String::from("nunjuks"), String::from(""));
mimes.insert(String::from("jinja"), String::from(""));
mimes.insert(String::from("bicep"), String::from(""));
mimes.insert(String::from("wasm"), String::from(""));
mimes.insert(String::from("docker"), String::from("󰡨"));
mimes.insert(String::from("docker-compose"), String::from("󰡨"));
mimes.insert(String::from("make"), String::from(""));
mimes.insert(String::from("cmake"), String::from(""));
mimes.insert(String::from("nix"), String::from(""));
mimes.insert(String::from("awk"), String::from(""));
mimes.insert(String::from("llvm"), String::from(""));
mimes.insert(String::from("llvm-mir"), String::from(""));
mimes.insert(String::from("regex"), String::from(""));
mimes.insert(String::from("graphql"), String::from(""));
mimes.insert(String::from("text"), String::from(""));
mimes.insert(String::from("markdown"), String::from(""));
mimes.insert(String::from("typst"), String::from(""));
mimes.insert(String::from("json"), String::from("󰘦"));
mimes.insert(String::from("toml"), String::from(""));
mimes.insert(String::from("xml"), String::from("󰗀"));
mimes.insert(String::from("latex"), String::from(""));
mimes.insert(String::from("git-commit"), String::from(""));
mimes.insert(String::from("git-rebase"), String::from(""));
mimes.insert(String::from("git-config"), String::from(""));
mimes.insert(String::from("todotxt"), String::from(""));
mimes.insert(String::from("hyprlang"), String::from(""));
mimes.insert(String::from("helm"), String::from(""));
mimes.insert(String::from("nginx"), String::from(""));
mimes
});
impl Mime {
#[inline]
pub fn directory(&self) -> &str {
if self.enabled {
return self.directory.as_ref().map_or("󰉋", |directory| directory);
} else if let Some(directory) = &self.directory {
return directory;
}
""
}
// Returns the symbol that matches the name, if any, otherwise returns the name back.
#[inline]
pub fn get<'name, 'mime: 'name>(&'mime self, name: &'name str) -> &'name str {
if self.enabled {
if let Some(symbol) = self.mime.get(name) {
return symbol;
} else if let Some(symbol) = MIMES.get(name) {
return symbol;
}
}
name
}
}
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Default)]
pub struct Dap {
verified: Option<String>,
unverified: Option<String>,
}
impl Dap {
#[inline]
pub fn verified(&self) -> &str {
self.verified.as_ref().map_or("●", |verified| verified)
}
#[inline]
pub fn unverified(&self) -> &str {
self.verified.as_ref().map_or("◯", |verified| verified)
}
}

1
helix-view/src/lib.rs
View file

@ -11,6 +11,7 @@ pub mod expansion;
pub mod graphics;
pub mod gutter;
pub mod handlers;
pub mod icons;
pub mod info;
pub mod input;
pub mod keyboard;