Merge 2234d94b50 into 7ebf650029

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",

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"

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" }

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<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)

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<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>,
 }

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<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)
+            }
         }
     }
 

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"

helix-tui/src/backend/crossterm.rs

@@ -2,9 +2,10 @@ use crate::{backend::Backend, buffer::Cell, terminal::Config};
 use crossterm::{
     cursor::{Hide, MoveTo, SetCursorStyle, Show},
     event::{
-        DisableBracketedPaste, DisableFocusChange, DisableMouseCapture, EnableBracketedPaste,
+        DisableBracketedPaste, DisableFocusChange, DisableMouseCapture, DisableThemeModeUpdates,
-        EnableFocusChange, EnableMouseCapture, KeyboardEnhancementFlags,
+        EnableBracketedPaste, EnableFocusChange, EnableMouseCapture, EnableThemeModeUpdates,
-        PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
+        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 features(&self) -> TerminalFeatures {
-    fn supports_keyboard_enhancement_protocol(&self) -> bool {
+        match self.features.get() {
-        *self.supports_keyboard_enhancement_protocol
+            Some(features) => features,
-            .get_or_init(|| {
+            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 {:?})",
+                    "Detected terminal features in {:?}. Enhanced keyboard support: {}, Synchronized output support: {}. Theme mode updates support: {}",
-                    if supported { "" } else { "not " },
+                    Instant::now().duration_since(now),
-                    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(
+                PushKeyboardEnhancementFlags(KEYBOARD_ENHANCEMENT_FLAGS)
-                    KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES
-                        | KeyboardEnhancementFlags::REPORT_ALTERNATE_KEYS
-                )
             )?;
+
+            // 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)]

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<Rect, io::Error>;
     fn flush(&mut self) -> Result<(), io::Error>;
+    fn get_theme_mode(&self) -> Option<theme::Mode>;
 }

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<helix_view::theme::Mode> {
+        None
+    }
 }

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
 

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<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,
+                })
+            }
         }
     }
 }

helix-view/src/theme.rs

@@ -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