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

Merge 2234d94b50 into 7ebf650029

Browse source
This commit is contained in:
Michael Davis 2025-04-01 11:37:37 +05:30 • committed by GitHub
commit f5552a9dc8
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
13 changed files with 197 additions and 60 deletions
Download patch file Download diff file Expand all files Collapse all files

44
Cargo.lock generated
View file

@ -236,25 +236,6 @@ version = "0.8.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
[[package]]
name = "crossterm"
version = "0.28.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6"
dependencies = [
"bitflags",
"crossterm_winapi",
"filedescriptor",
"futures-core",
"libc",
"mio",
"parking_lot",
"rustix 0.38.44",
"signal-hook",
"signal-hook-mio",
"winapi",
]
[[package]]
name = "crossterm_winapi"
version = "0.9.1"
@ -1354,6 +1335,25 @@ dependencies = [
"url",
]
[[package]]
name = "helix-crossterm"
version = "0.1.0-beta.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8938f95c101672e5084b377daac1f78ed5964c2a75046fc0d29d66cbed975f8c"
dependencies = [
"bitflags",
"crossterm_winapi",
"filedescriptor",
"futures-core",
"libc",
"mio",
"parking_lot",
"rustix 0.38.44",
"signal-hook",
"signal-hook-mio",
"winapi",
]
[[package]]
name = "helix-dap"
version = "25.1.1"
@ -1464,12 +1464,12 @@ dependencies = [
"arc-swap",
"chrono",
"content_inspector",
"crossterm",
"fern",
"futures-util",
"grep-regex",
"grep-searcher",
"helix-core",
"helix-crossterm",
"helix-dap",
"helix-event",
"helix-loader",
@ -1508,8 +1508,8 @@ version = "25.1.1"
dependencies = [
"bitflags",
"cassowary",
"crossterm",
"helix-core",
"helix-crossterm",
"helix-view",
"log",
"once_cell",
@ -1542,9 +1542,9 @@ dependencies = [
"bitflags",
"chardetng",
"clipboard-win",
"crossterm",
"futures-util",
"helix-core",
"helix-crossterm",
"helix-dap",
"helix-event",
"helix-loader",

1
Cargo.toml
View file

@ -47,6 +47,7 @@ unicode-segmentation = "1.2"
ropey = { version = "1.6.1", default-features = false, features = ["simd"] }
foldhash = "0.1"
parking_lot = "0.12"
crossterm = { package = "helix-crossterm", version = "0.1.0-beta.1" }
[workspace.package]
version = "25.1.1"

4
helix-term/Cargo.toml
View file

@ -55,7 +55,7 @@ once_cell = "1.21"
tokio = { version = "1", features = ["rt", "rt-multi-thread", "io-util", "io-std", "time", "process", "macros", "fs", "parking_lot"] }
tui = { path = "../helix-tui", package = "helix-tui", default-features = false, features = ["crossterm"] }
crossterm = { version = "0.28", features = ["event-stream"] }
crossterm = { workspace = true, features = ["event-stream"] }
signal-hook = "0.3"
tokio-stream = "0.1"
futures-util = { version = "0.3", features = ["std", "async-await"], default-features = false }
@ -96,7 +96,7 @@ signal-hook-tokio = { version = "0.3", features = ["futures-v0_3"] }
libc = "0.2.171"
[target.'cfg(target_os = "macos")'.dependencies]
crossterm = { version = "0.28", features = ["event-stream", "use-dev-tty", "libc"] }
crossterm = { workspace = true, features = ["event-stream", "use-dev-tty", "libc"] }
[build-dependencies]
helix-loader = { path = "../helix-loader" }

19
helix-term/src/application.rs
View file

@ -68,6 +68,9 @@ pub struct Application {
signals: Signals,
jobs: Jobs,
lsp_progress: LspProgressMap,
/// The theme mode (light/dark) detected from the terminal, if available.
theme_mode: Option<theme::Mode>,
}
#[cfg(feature = "integration")]
@ -109,6 +112,7 @@ impl Application {
#[cfg(feature = "integration")]
let backend = TestBackend::new(120, 150);
let theme_mode = backend.get_theme_mode();
let terminal = Terminal::new(backend)?;
let area = terminal.size().expect("couldn't get terminal size");
let mut compositor = Compositor::new(area);
@ -123,12 +127,15 @@ impl Application {
})),
handlers,
);
Self::load_configured_theme(&mut editor, &config.load());
Self::load_configured_theme(&mut editor, &config.load(), theme_mode);
let keys = Box::new(Map::new(Arc::clone(&config), |config: &Config| {
&config.keys
}));
let editor_view = Box::new(ui::EditorView::new(Keymaps::new(keys)));
let editor_view = Box::new(ui::EditorView::new(
Keymaps::new(keys),
Map::new(Arc::clone(&config), |config: &Config| &config.theme),
));
compositor.push(editor_view);
if args.load_tutor {
@ -242,6 +249,7 @@ impl Application {
signals,
jobs: Jobs::new(),
lsp_progress: LspProgressMap::new(),
theme_mode,
};
Ok(app)
@ -408,7 +416,7 @@ impl Application {
.map_err(|err| anyhow::anyhow!("Failed to load config: {}", err))?;
self.refresh_language_config()?;
// Refresh theme after config change
Self::load_configured_theme(&mut self.editor, &default_config);
Self::load_configured_theme(&mut self.editor, &default_config, self.theme_mode);
self.terminal
.reconfigure(default_config.editor.clone().into())?;
// Store new config
@ -427,12 +435,13 @@ impl Application {
}
/// Load the theme set in configuration
fn load_configured_theme(editor: &mut Editor, config: &Config) {
fn load_configured_theme(editor: &mut Editor, config: &Config, mode: Option<theme::Mode>) {
let true_color = config.editor.true_color || crate::true_color();
let theme = config
.theme
.as_ref()
.and_then(|theme| {
.and_then(|theme_config| {
let theme = theme_config.choose(mode);
editor
.theme_loader
.load(theme)

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

@ -1,7 +1,7 @@
use crate::keymap;
use crate::keymap::{merge_keys, KeyTrie};
use helix_loader::merge_toml_values;
use helix_view::document::Mode;
use helix_view::{document::Mode, theme};
use serde::Deserialize;
use std::collections::HashMap;
use std::fmt::Display;
@ -11,7 +11,7 @@ use toml::de::Error as TomlError;
#[derive(Debug, Clone, PartialEq)]
pub struct Config {
pub theme: Option<String>,
pub theme: Option<theme::Config>,
pub keys: HashMap<Mode, KeyTrie>,
pub editor: helix_view::editor::Config,
}
@ -19,7 +19,7 @@ pub struct Config {
#[derive(Debug, Clone, PartialEq, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ConfigRaw {
pub theme: Option<String>,
pub theme: Option<theme::Config>,
pub keys: Option<HashMap<Mode, KeyTrie>>,
pub editor: Option<toml::Value>,
}

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

@ -13,6 +13,7 @@ use crate::{
},
};
use arc_swap::access::DynAccess;
use helix_core::{
diagnostic::NumberOrString,
graphemes::{next_grapheme_boundary, prev_grapheme_boundary},
@ -29,7 +30,7 @@ use helix_view::{
graphics::{Color, CursorKind, Modifier, Rect, Style},
input::{KeyEvent, MouseButton, MouseEvent, MouseEventKind},
keyboard::{KeyCode, KeyModifiers},
Document, Editor, Theme, View,
theme, Document, Editor, Theme, View,
};
use std::{mem::take, num::NonZeroUsize, path::PathBuf, rc::Rc};
@ -37,6 +38,7 @@ use tui::{buffer::Buffer as Surface, text::Span};
pub struct EditorView {
pub keymaps: Keymaps,
theme_config: Box<dyn DynAccess<Option<theme::Config>>>,
on_next_key: Option<(OnKeyCallback, OnKeyCallbackKind)>,
pseudo_pending: Vec<KeyEvent>,
pub(crate) last_insert: (commands::MappableCommand, Vec<InsertEvent>),
@ -58,9 +60,13 @@ pub enum InsertEvent {
}
impl EditorView {
pub fn new(keymaps: Keymaps) -> Self {
pub fn new(
keymaps: Keymaps,
theme_config: impl DynAccess<Option<theme::Config>> + 'static,
) -> Self {
Self {
keymaps,
theme_config: Box::new(theme_config),
on_next_key: None,
pseudo_pending: Vec::new(),
last_insert: (commands::MappableCommand::normal_mode, Vec::new()),
@ -1535,6 +1541,18 @@ impl Component for EditorView {
self.terminal_focused = false;
EventResult::Consumed(None)
}
Event::ThemeModeChanged(theme_mode) => {
if let Some(theme_config) = self.theme_config.load().as_ref() {
let theme_name = theme_config.choose(Some(*theme_mode));
match context.editor.theme_loader.load(theme_name) {
Ok(theme) => context.editor.set_theme(theme),
Err(err) => {
log::warn!("failed to load theme `{}` - {}", theme_name, err);
}
}
}
EventResult::Consumed(None)
}
}
}

2
helix-tui/Cargo.toml
View file

@ -21,7 +21,7 @@ helix-core = { path = "../helix-core" }
bitflags.workspace = true
cassowary = "0.3"
unicode-segmentation.workspace = true
crossterm = { version = "0.28", optional = true }
crossterm = { workspace = true, optional = true }
termini = "1.0"
once_cell = "1.21"
log = "~0.4"

95
helix-tui/src/backend/crossterm.rs
View file

@ -2,9 +2,10 @@ use crate::{backend::Backend, buffer::Cell, terminal::Config};
use crossterm::{
cursor::{Hide, MoveTo, SetCursorStyle, Show},
event::{
DisableBracketedPaste, DisableFocusChange, DisableMouseCapture, EnableBracketedPaste,
EnableFocusChange, EnableMouseCapture, KeyboardEnhancementFlags,
PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
DisableBracketedPaste, DisableFocusChange, DisableMouseCapture, DisableThemeModeUpdates,
EnableBracketedPaste, EnableFocusChange, EnableMouseCapture, EnableThemeModeUpdates,
KeyboardEnhancementFlags, PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
SynchronizedOutputMode, TerminalFeatures,
},
execute, queue,
style::{
@ -17,14 +18,18 @@ use crossterm::{
use helix_view::{
editor::Config as EditorConfig,
graphics::{Color, CursorKind, Modifier, Rect, UnderlineStyle},
theme,
};
use once_cell::sync::OnceCell;
use std::{
fmt,
io::{self, Write},
};
use termini::TermInfo;
const KEYBOARD_ENHANCEMENT_FLAGS: KeyboardEnhancementFlags =
KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES
.union(KeyboardEnhancementFlags::REPORT_ALTERNATE_KEYS);
fn term_program() -> Option<String> {
// Some terminals don't set $TERM_PROGRAM
match std::env::var("TERM_PROGRAM") {
@ -98,7 +103,7 @@ impl Capabilities {
pub struct CrosstermBackend<W: Write> {
buffer: W,
capabilities: Capabilities,
supports_keyboard_enhancement_protocol: OnceCell<bool>,
features: std::cell::Cell<Option<TerminalFeatures>>,
mouse_capture_enabled: bool,
supports_bracketed_paste: bool,
}
@ -115,27 +120,35 @@ where
CrosstermBackend {
buffer,
capabilities: Capabilities::from_env_or_default(config),
supports_keyboard_enhancement_protocol: OnceCell::new(),
features: std::cell::Cell::new(None),
mouse_capture_enabled: false,
supports_bracketed_paste: true,
}
}
#[inline]
fn supports_keyboard_enhancement_protocol(&self) -> bool {
*self.supports_keyboard_enhancement_protocol
.get_or_init(|| {
fn features(&self) -> TerminalFeatures {
match self.features.get() {
Some(features) => features,
None => {
use std::time::Instant;
let now = Instant::now();
let supported = matches!(terminal::supports_keyboard_enhancement(), Ok(true));
let features = terminal::terminal_features().unwrap_or_default();
log::debug!(
"The keyboard enhancement protocol is {}supported in this terminal (checked in {:?})",
if supported { "" } else { "not " },
Instant::now().duration_since(now)
"Detected terminal features in {:?}. Enhanced keyboard support: {}, Synchronized output support: {}. Theme mode updates support: {}",
Instant::now().duration_since(now),
features.keyboard_enhancement_flags.is_some(),
features.synchronized_output_mode != SynchronizedOutputMode::NotSupported,
features.theme_mode.is_some(),
);
supported
})
self.features.set(Some(features));
features
}
}
}
fn supports_synchronized_output(&self) -> bool {
self.features().synchronized_output_mode != SynchronizedOutputMode::NotSupported
}
}
@ -176,14 +189,28 @@ where
execute!(self.buffer, EnableMouseCapture)?;
self.mouse_capture_enabled = true;
}
if self.supports_keyboard_enhancement_protocol() {
let features = self.features();
if features.theme_mode.is_some() {
execute!(self.buffer, EnableThemeModeUpdates)?;
}
if features.keyboard_enhancement_flags.is_some() {
execute!(
self.buffer,
PushKeyboardEnhancementFlags(
KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES
| KeyboardEnhancementFlags::REPORT_ALTERNATE_KEYS
)
PushKeyboardEnhancementFlags(KEYBOARD_ENHANCEMENT_FLAGS)
)?;
// If the terminal supports a limited subset of the keyboard enhancement protocol,
// turn it off. We need both `DISAMBIGUATE_ESCAPE_CODES` and `REPORT_ALTERNATE_KEYS`.
if let Ok(Some(flags)) = terminal::query_keyboard_enhancement_flags() {
if !flags.contains(KEYBOARD_ENHANCEMENT_FLAGS) {
log::info!("Turning off keyboard enhancement since the terminal didn't enable the required flags. Expected {KEYBOARD_ENHANCEMENT_FLAGS:?}, found {flags:?}");
self.features.set(Some(TerminalFeatures {
keyboard_enhancement_flags: None,
..features
}));
execute!(self.buffer, PopKeyboardEnhancementFlags)?;
}
}
}
Ok(())
}
@ -208,9 +235,13 @@ where
if config.enable_mouse_capture {
execute!(self.buffer, DisableMouseCapture)?;
}
if self.supports_keyboard_enhancement_protocol() {
let features = self.features();
if features.keyboard_enhancement_flags.is_some() {
execute!(self.buffer, PopKeyboardEnhancementFlags)?;
}
if features.theme_mode.is_some() {
execute!(self.buffer, DisableThemeModeUpdates)?;
}
if self.supports_bracketed_paste {
execute!(self.buffer, DisableBracketedPaste,)?;
}
@ -231,6 +262,7 @@ where
// disable without calling enable previously
let _ = execute!(stdout, DisableMouseCapture);
let _ = execute!(stdout, PopKeyboardEnhancementFlags);
let _ = execute!(stdout, DisableThemeModeUpdates);
let _ = execute!(stdout, DisableBracketedPaste);
execute!(stdout, DisableFocusChange, terminal::LeaveAlternateScreen)?;
terminal::disable_raw_mode()
@ -240,6 +272,10 @@ where
where
I: Iterator<Item = (u16, u16, &'a Cell)>,
{
if self.supports_synchronized_output() {
queue!(self.buffer, terminal::BeginSynchronizedUpdate)?;
}
let mut fg = Color::Reset;
let mut bg = Color::Reset;
let mut underline_color = Color::Reset;
@ -298,7 +334,13 @@ where
SetForegroundColor(CColor::Reset),
SetBackgroundColor(CColor::Reset),
SetAttribute(CAttribute::Reset)
)
)?;
if self.supports_synchronized_output() {
execute!(self.buffer, terminal::EndSynchronizedUpdate)?;
}
Ok(())
}
fn hide_cursor(&mut self) -> io::Result<()> {
@ -338,6 +380,13 @@ where
fn flush(&mut self) -> io::Result<()> {
self.buffer.flush()
}
fn get_theme_mode(&self) -> Option<theme::Mode> {
self.features().theme_mode.map(|mode| match mode {
crossterm::event::ThemeMode::Light => theme::Mode::Light,
crossterm::event::ThemeMode::Dark => theme::Mode::Dark,
})
}
}
#[derive(Debug)]

6
helix-tui/src/backend/mod.rs
View file

@ -2,7 +2,10 @@ use std::io;
use crate::{buffer::Cell, terminal::Config};
use helix_view::graphics::{CursorKind, Rect};
use helix_view::{
graphics::{CursorKind, Rect},
theme,
};
#[cfg(feature = "crossterm")]
mod crossterm;
@ -27,4 +30,5 @@ pub trait Backend {
fn clear(&mut self) -> Result<(), io::Error>;
fn size(&self) -> Result<Rect, io::Error>;
fn flush(&mut self) -> Result<(), io::Error>;
fn get_theme_mode(&self) -> Option<theme::Mode>;
}

4
helix-tui/src/backend/test.rs
View file

@ -164,4 +164,8 @@ impl Backend for TestBackend {
fn flush(&mut self) -> Result<(), io::Error> {
Ok(())
}
fn get_theme_mode(&self) -> Option<helix_view::theme::Mode> {
None
}
}

2
helix-view/Cargo.toml
View file

@ -26,7 +26,7 @@ helix-vcs = { path = "../helix-vcs" }
bitflags.workspace = true
anyhow = "1"
crossterm = { version = "0.28", optional = true }
crossterm = { workspace = true, optional = true }
tempfile.workspace = true

8
helix-view/src/input.rs
View file

@ -5,6 +5,7 @@ use serde::de::{self, Deserialize, Deserializer};
use std::fmt;
pub use crate::keyboard::{KeyCode, KeyModifiers, MediaKeyCode, ModifierKeyCode};
use crate::theme;
#[derive(Debug, PartialOrd, PartialEq, Eq, Clone, Hash)]
pub enum Event {
@ -14,6 +15,7 @@ pub enum Event {
Mouse(MouseEvent),
Paste(String),
Resize(u16, u16),
ThemeModeChanged(theme::Mode),
IdleTimeout,
}
@ -468,6 +470,12 @@ impl From<crossterm::event::Event> for Event {
crossterm::event::Event::FocusGained => Self::FocusGained,
crossterm::event::Event::FocusLost => Self::FocusLost,
crossterm::event::Event::Paste(s) => Self::Paste(s),
crossterm::event::Event::ThemeModeChanged(theme_mode) => {
Self::ThemeModeChanged(match theme_mode {
crossterm::event::ThemeMode::Light => theme::Mode::Light,
crossterm::event::ThemeMode::Dark => theme::Mode::Dark,
})
}
}
}
}

44
helix-view/src/theme.rs
View file

@ -35,6 +35,50 @@ pub static BASE16_DEFAULT_THEME: Lazy<Theme> = Lazy::new(|| Theme {
..Theme::from(BASE16_DEFAULT_THEME_DATA.clone())
});
#[derive(Debug, PartialOrd, PartialEq, Eq, Clone, Copy, Hash)]
pub enum Mode {
Light,
Dark,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Config {
light: String,
dark: String,
}
impl Config {
pub fn choose(&self, preference: Option<Mode>) -> &str {
match preference {
Some(Mode::Light) => &self.light,
Some(Mode::Dark) | None => &self.dark,
}
}
}
impl<'de> Deserialize<'de> for Config {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(untagged, deny_unknown_fields)]
enum InnerConfig {
Constant(String),
Adaptive { dark: String, light: String },
}
let inner = InnerConfig::deserialize(deserializer)?;
let (light, dark) = match inner {
InnerConfig::Constant(theme) => (theme.clone(), theme),
InnerConfig::Adaptive { light, dark } => (light, dark),
};
Ok(Self { light, dark })
}
}
#[derive(Clone, Debug)]
pub struct Loader {
/// Theme directories to search from highest to lowest priority