From d1a3c66ee4f04753bd71c38114a57920cc00543e Mon Sep 17 00:00:00 2001 From: Michael Davis Date: Fri, 28 Mar 2025 12:13:50 -0400 Subject: [PATCH 1/4] Use 'helix-crossterm' soft fork --- Cargo.lock | 44 +++++++++++++++++++++---------------------- Cargo.toml | 1 + helix-term/Cargo.toml | 4 ++-- helix-tui/Cargo.toml | 2 +- helix-view/Cargo.toml | 2 +- 5 files changed, 27 insertions(+), 26 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index cabb98a70..7ea565884 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -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", diff --git a/Cargo.toml b/Cargo.toml index 667a83967..e188e3d88 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -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" diff --git a/helix-term/Cargo.toml b/helix-term/Cargo.toml index 9ea2d4589..c999981ce 100644 --- a/helix-term/Cargo.toml +++ b/helix-term/Cargo.toml @@ -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" } diff --git a/helix-tui/Cargo.toml b/helix-tui/Cargo.toml index 2b5767a58..fa52a7c75 100644 --- a/helix-tui/Cargo.toml +++ b/helix-tui/Cargo.toml @@ -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" diff --git a/helix-view/Cargo.toml b/helix-view/Cargo.toml index bcee1a0a7..0913188ba 100644 --- a/helix-view/Cargo.toml +++ b/helix-view/Cargo.toml @@ -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 From c02663860dae1083f67542c9a2e384086525fb5f Mon Sep 17 00:00:00 2001 From: Michael Davis Date: Fri, 28 Mar 2025 12:21:56 -0400 Subject: [PATCH 2/4] Detect and subscribe to theme mode updates Historically we haven't wanted to add light/dark mode since it required platform-specific dependencies. The Contour terminal [proposed] a VT extension to query for the current mode and subscribe to future changes, however, which can be supported squarely in Crossterm with no new deps. Currently at least Contour, Kitty and Ghostty support this on the terminal emulator side and Neovim on the client side. This patch allows configuring multiple themes: # this is still accepted: # theme = "ayu_dark" theme = { dark = "ayu_dark", light = "ayu_light" } On startup we query the terminal for the current mode and choose that theme. We then receive events from crossterm whenever the terminal changes theme. [proposed]: https://github.com/contour-terminal/contour/blob/master/docs/vt-extensions/color-palette-update-notifications.md --- helix-term/src/application.rs | 19 +++++++++---- helix-term/src/config.rs | 6 ++-- helix-term/src/ui/editor.rs | 22 +++++++++++++-- helix-tui/src/backend/crossterm.rs | 33 ++++++++++++++++++++-- helix-tui/src/backend/mod.rs | 6 +++- helix-tui/src/backend/test.rs | 4 +++ helix-view/src/input.rs | 8 ++++++ helix-view/src/theme.rs | 44 ++++++++++++++++++++++++++++++ 8 files changed, 128 insertions(+), 14 deletions(-) diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index 16a26cb26..ffa8f3f8f 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -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, } #[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) { 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) diff --git a/helix-term/src/config.rs b/helix-term/src/config.rs index bcba8d8e1..dd0519841 100644 --- a/helix-term/src/config.rs +++ b/helix-term/src/config.rs @@ -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, + pub theme: Option, pub keys: HashMap, 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, + pub theme: Option, pub keys: Option>, pub editor: Option, } diff --git a/helix-term/src/ui/editor.rs b/helix-term/src/ui/editor.rs index 6be565747..0165ae143 100644 --- a/helix-term/src/ui/editor.rs +++ b/helix-term/src/ui/editor.rs @@ -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>>, on_next_key: Option<(OnKeyCallback, OnKeyCallbackKind)>, pseudo_pending: Vec, pub(crate) last_insert: (commands::MappableCommand, Vec), @@ -58,9 +60,13 @@ pub enum InsertEvent { } impl EditorView { - pub fn new(keymaps: Keymaps) -> Self { + pub fn new( + keymaps: Keymaps, + theme_config: impl DynAccess> + '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) + } } } diff --git a/helix-tui/src/backend/crossterm.rs b/helix-tui/src/backend/crossterm.rs index e8947ee08..4d0b82d1f 100644 --- a/helix-tui/src/backend/crossterm.rs +++ b/helix-tui/src/backend/crossterm.rs @@ -2,9 +2,9 @@ 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, }, execute, queue, style::{ @@ -17,6 +17,7 @@ use crossterm::{ use helix_view::{ editor::Config as EditorConfig, graphics::{Color, CursorKind, Modifier, Rect, UnderlineStyle}, + theme, }; use once_cell::sync::OnceCell; use std::{ @@ -176,6 +177,7 @@ where execute!(self.buffer, EnableMouseCapture)?; self.mouse_capture_enabled = true; } + execute!(self.buffer, EnableThemeModeUpdates).ok(); if self.supports_keyboard_enhancement_protocol() { execute!( self.buffer, @@ -219,6 +221,7 @@ where DisableFocusChange, terminal::LeaveAlternateScreen )?; + execute!(self.buffer, DisableThemeModeUpdates).ok(); terminal::disable_raw_mode() } @@ -231,6 +234,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() @@ -338,6 +342,29 @@ where fn flush(&mut self) -> io::Result<()> { self.buffer.flush() } + + fn get_theme_mode(&self) -> Option { + use std::time::Instant; + + let start = Instant::now(); + let theme_mode = crossterm::terminal::query_terminal_theme_mode() + .ok() + .flatten() + .map(|theme_mode| match theme_mode { + crossterm::event::ThemeMode::Light => theme::Mode::Light, + crossterm::event::ThemeMode::Dark => theme::Mode::Dark, + }); + let elapsed = Instant::now().duration_since(start).as_millis(); + if theme_mode.is_some() { + log::debug!("detected terminal theme mode in {}ms", elapsed); + } else { + log::debug!( + "failed to detect terminal theme mode (checked in {}ms)", + elapsed + ); + } + theme_mode + } } #[derive(Debug)] diff --git a/helix-tui/src/backend/mod.rs b/helix-tui/src/backend/mod.rs index 6994bc6f5..22c61c0d8 100644 --- a/helix-tui/src/backend/mod.rs +++ b/helix-tui/src/backend/mod.rs @@ -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; fn flush(&mut self) -> Result<(), io::Error>; + fn get_theme_mode(&self) -> Option; } diff --git a/helix-tui/src/backend/test.rs b/helix-tui/src/backend/test.rs index 771cc3094..5fb1be4ff 100644 --- a/helix-tui/src/backend/test.rs +++ b/helix-tui/src/backend/test.rs @@ -164,4 +164,8 @@ impl Backend for TestBackend { fn flush(&mut self) -> Result<(), io::Error> { Ok(()) } + + fn get_theme_mode(&self) -> Option { + None + } } diff --git a/helix-view/src/input.rs b/helix-view/src/input.rs index d359db703..2a1768aef 100644 --- a/helix-view/src/input.rs +++ b/helix-view/src/input.rs @@ -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 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, + }) + } } } } diff --git a/helix-view/src/theme.rs b/helix-view/src/theme.rs index af8f03bca..6e54a6508 100644 --- a/helix-view/src/theme.rs +++ b/helix-view/src/theme.rs @@ -35,6 +35,50 @@ pub static BASE16_DEFAULT_THEME: Lazy = 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) -> &str { + match preference { + Some(Mode::Light) => &self.light, + Some(Mode::Dark) | None => &self.dark, + } + } +} + +impl<'de> Deserialize<'de> for Config { + fn deserialize(deserializer: D) -> Result + 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 From 9558cb4002fe98f485958044e497a6644771e363 Mon Sep 17 00:00:00 2001 From: Michael Davis Date: Fri, 28 Mar 2025 12:39:04 -0400 Subject: [PATCH 3/4] crossterm: Use the TerminalFeatures query `cossterm::terminal::terminal_features` queries for all VT extension features at once and gives back a small struct with the current state of each feature. We can use this struct to determine which features the terminal supports. This patch changes to prefer this feature over individual queries like `supports_keyboard_enhancement` and `query_terminal_theme_mode`. This also updates our handling of the Kitty keyboard protocol. Once we enable the protocol we ask the terminal for the currently enabled flags. If we see that the terminal hasn't enabled the requested flags then we turn off the feature. This is intended for Zellij which doesn't support the `REPORT_ALTERNATE_KEYS` flag. When `DISAMBIGUATE_ESCAPE_CODES` is enabled but not `REPORT_ALTERNATE_KEYS` we get key combinations like `A-S-9` instead of `A-(` (which we also get without the enhanced keyboard protocol). Disabling the protocol is simpler in this case than normalizing based on the keyboard. --- helix-tui/src/backend/crossterm.rs | 90 ++++++++++++++++-------------- 1 file changed, 49 insertions(+), 41 deletions(-) diff --git a/helix-tui/src/backend/crossterm.rs b/helix-tui/src/backend/crossterm.rs index 4d0b82d1f..5b41585e9 100644 --- a/helix-tui/src/backend/crossterm.rs +++ b/helix-tui/src/backend/crossterm.rs @@ -5,6 +5,7 @@ use crossterm::{ DisableBracketedPaste, DisableFocusChange, DisableMouseCapture, DisableThemeModeUpdates, EnableBracketedPaste, EnableFocusChange, EnableMouseCapture, EnableThemeModeUpdates, KeyboardEnhancementFlags, PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags, + SynchronizedOutputMode, TerminalFeatures, }, execute, queue, style::{ @@ -19,13 +20,16 @@ use helix_view::{ 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 { // Some terminals don't set $TERM_PROGRAM match std::env::var("TERM_PROGRAM") { @@ -99,7 +103,7 @@ impl Capabilities { pub struct CrosstermBackend { buffer: W, capabilities: Capabilities, - supports_keyboard_enhancement_protocol: OnceCell, + features: std::cell::Cell>, mouse_capture_enabled: bool, supports_bracketed_paste: bool, } @@ -116,27 +120,31 @@ 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 + } + } } } @@ -177,15 +185,28 @@ where execute!(self.buffer, EnableMouseCapture)?; self.mouse_capture_enabled = true; } - execute!(self.buffer, EnableThemeModeUpdates).ok(); - 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(()) } @@ -210,9 +231,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,)?; } @@ -221,7 +246,6 @@ where DisableFocusChange, terminal::LeaveAlternateScreen )?; - execute!(self.buffer, DisableThemeModeUpdates).ok(); terminal::disable_raw_mode() } @@ -344,26 +368,10 @@ where } fn get_theme_mode(&self) -> Option { - use std::time::Instant; - - let start = Instant::now(); - let theme_mode = crossterm::terminal::query_terminal_theme_mode() - .ok() - .flatten() - .map(|theme_mode| match theme_mode { - crossterm::event::ThemeMode::Light => theme::Mode::Light, - crossterm::event::ThemeMode::Dark => theme::Mode::Dark, - }); - let elapsed = Instant::now().duration_since(start).as_millis(); - if theme_mode.is_some() { - log::debug!("detected terminal theme mode in {}ms", elapsed); - } else { - log::debug!( - "failed to detect terminal theme mode (checked in {}ms)", - elapsed - ); - } - theme_mode + self.features().theme_mode.map(|mode| match mode { + crossterm::event::ThemeMode::Light => theme::Mode::Light, + crossterm::event::ThemeMode::Dark => theme::Mode::Dark, + }) } } From 2234d94b5066d96a97e266c9cb32937f46893f19 Mon Sep 17 00:00:00 2001 From: Michael Davis Date: Fri, 28 Mar 2025 12:49:27 -0400 Subject: [PATCH 4/4] crossterm: Render with synchronized output This takes advantage of the synchronized output commands from crossterm to tell the terminal emulator when to pause and resume drawing. This should feel snappier and have fewer visual artifacts like tearing when we update the screen with many changes (scrolling or changing theme for example). --- helix-tui/src/backend/crossterm.rs | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/helix-tui/src/backend/crossterm.rs b/helix-tui/src/backend/crossterm.rs index 5b41585e9..acb0fdfeb 100644 --- a/helix-tui/src/backend/crossterm.rs +++ b/helix-tui/src/backend/crossterm.rs @@ -146,6 +146,10 @@ where } } } + + fn supports_synchronized_output(&self) -> bool { + self.features().synchronized_output_mode != SynchronizedOutputMode::NotSupported + } } impl Write for CrosstermBackend @@ -268,6 +272,10 @@ where where I: Iterator, { + 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; @@ -326,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<()> {