Support querying the state of all VT extension features at once

Querying for each feature individually can cause some latency. This
change introduces a struct with fields for all VT extension features and
a function to query all at once.

Author: the-mikedavis

src/event.rs

@@ -1573,6 +1573,17 @@ pub enum ThemeMode {
     Dark,
 }
 
+/// The current state of features supported by the terminal.
+///
+/// This can be queried with [terminal::terminal_features].
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct TerminalFeatures {
+    pub keyboard_enhancement_flags: Option<KeyboardEnhancementFlags>,
+    pub synchronized_output_mode: Option<SynchronizedOutputMode>,
+    pub theme_mode: Option<ThemeMode>,
+}
+
 #[cfg(test)]
 mod tests {
     use std::collections::hash_map::DefaultHasher;

src/event/filter.rs

@@ -81,6 +81,26 @@ impl Filter for SynchronizedOutputModeFilter {
     }
 }
 
+#[cfg(unix)]
+#[derive(Debug, Clone)]
+pub(crate) struct TerminalFeaturesFilter;
+
+#[cfg(unix)]
+impl Filter for TerminalFeaturesFilter {
+    fn eval(&self, event: &InternalEvent) -> bool {
+        // See `KeyboardEnhancementFlagsFilter` above: `PrimaryDeviceAttributes` is
+        // used to elicit a response from the terminal even if it doesn't support the
+        // synchronized output mode query.
+        matches!(
+            *event,
+            InternalEvent::KeyboardEnhancementFlags(_)
+                | InternalEvent::Event(Event::ThemeModeChanged(_))
+                | InternalEvent::SynchronizedOutputMode(_)
+                | InternalEvent::PrimaryDeviceAttributes
+        )
+    }
+}
+
 #[derive(Debug, Clone)]
 pub(crate) struct EventFilter;
 

src/terminal.rs

@@ -101,7 +101,7 @@ pub(crate) mod sys;
 #[cfg(feature = "events")]
 pub use sys::{
     query_keyboard_enhancement_flags, query_terminal_theme_mode, supports_keyboard_enhancement,
-    supports_synchronized_output,
+    supports_synchronized_output, terminal_features,
 };
 
 /// Tells whether the raw mode is enabled.

src/terminal/sys.rs

@@ -8,7 +8,7 @@ pub(crate) use self::unix::{
 #[cfg(feature = "events")]
 pub use self::unix::{
     query_keyboard_enhancement_flags, query_terminal_theme_mode, supports_keyboard_enhancement,
-    supports_synchronized_output,
+    supports_synchronized_output, terminal_features,
 };
 #[cfg(all(windows, test))]
 pub(crate) use self::windows::temp_screen_buffer;
@@ -21,7 +21,7 @@ pub(crate) use self::windows::{
 #[cfg(feature = "events")]
 pub use self::windows::{
     query_keyboard_enhancement_flags, query_terminal_theme_mode, supports_keyboard_enhancement,
-    supports_synchronized_output,
+    supports_synchronized_output, terminal_features,
 };
 
 #[cfg(windows)]

src/terminal/sys/unix.rs

@@ -1,7 +1,7 @@
 //! UNIX related logic for terminal manipulation.
 
 #[cfg(feature = "events")]
-use crate::event::{KeyboardEnhancementFlags, ThemeMode};
+use crate::event::{KeyboardEnhancementFlags, TerminalFeatures, ThemeMode};
 use crate::terminal::{
     sys::file_descriptor::{tty_fd, FileDesc},
     WindowSize,
@@ -401,6 +401,82 @@ fn query_keyboard_enhancement_flags_raw() -> io::Result<Option<KeyboardEnhanceme
     }
 }
 
+/// Queries information about features that the terminal supports.
+///
+/// On unix systems, this function will block and possibly time out while
+/// [`crossterm::event::read`](crate::event::read) or [`crossterm::event::poll`](crate::event::poll) are being called.
+#[cfg(feature = "events")]
+pub fn terminal_features() -> io::Result<TerminalFeatures> {
+    if is_raw_mode_enabled() {
+        terminal_features_raw()
+    } else {
+        terminal_features_nonraw()
+    }
+}
+
+#[cfg(feature = "events")]
+fn terminal_features_nonraw() -> io::Result<TerminalFeatures> {
+    enable_raw_mode()?;
+    let features = terminal_features_raw();
+    disable_raw_mode()?;
+    features
+}
+
+#[cfg(feature = "events")]
+fn terminal_features_raw() -> io::Result<TerminalFeatures> {
+    use crate::event::{
+        filter::TerminalFeaturesFilter, poll_internal, read_internal, Event, InternalEvent,
+    };
+    use std::io::Write;
+    use std::time::Duration;
+
+    // This is the recommended method for testing support for the keyboard enhancement protocol.
+    // We send a query for the flags supported by the terminal and then the primary device attributes
+    // query. If we receive the primary device attributes response but not the keyboard enhancement
+    // flags, none of the flags are supported.
+    //
+    // See <https://sw.kovidgoyal.net/kitty/keyboard-protocol/#detection-of-support-for-this-protocol>
+
+    // ESC [ ? u        Query progressive keyboard enhancement flags (kitty protocol).
+    // ESC [ c          Query primary device attributes.
+    const QUERY: &[u8] = b"\x1B[?u\x1B[c";
+
+    let result = File::open("/dev/tty").and_then(|mut file| {
+        file.write_all(QUERY)?;
+        file.flush()
+    });
+    if result.is_err() {
+        let mut stdout = io::stdout();
+        stdout.write_all(QUERY)?;
+        stdout.flush()?;
+    }
+
+    let mut features = TerminalFeatures::default();
+    loop {
+        match poll_internal(Some(Duration::from_millis(2000)), &TerminalFeaturesFilter) {
+            Ok(true) => match read_internal(&TerminalFeaturesFilter) {
+                Ok(InternalEvent::KeyboardEnhancementFlags(flags)) => {
+                    features.keyboard_enhancement_flags = Some(flags);
+                }
+                Ok(InternalEvent::SynchronizedOutputMode(mode)) => {
+                    features.synchronized_output_mode = Some(mode);
+                }
+                Ok(InternalEvent::Event(Event::ThemeModeChanged(theme_mode))) => {
+                    features.theme_mode = Some(theme_mode);
+                }
+                _ => return Ok(features),
+            },
+            Ok(false) => {
+                return Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    "Terminal information could not be read within a normal duration",
+                ));
+            }
+            Err(_) => {}
+        }
+    }
+}
+
 /// execute tput with the given argument and parse
 /// the output as a u16.
 ///

src/terminal/sys/windows.rs

@@ -10,7 +10,7 @@ use winapi::{
 };
 
 #[cfg(feature = "events")]
-use crate::event::{KeyboardEnhancementFlags, ThemeMode};
+use crate::event::{KeyboardEnhancementFlags, TerminalFeatures, ThemeMode};
 use crate::{
     cursor,
     terminal::{ClearType, WindowSize},
@@ -102,6 +102,11 @@ pub fn query_terminal_theme_mode() -> io::Result<Option<ThemeMode>> {
     Ok(None)
 }
 
+#[cfg(feature = "events")]
+pub fn terminal_features() -> io::Result<TerminalFeatures> {
+    Ok(TerminalFeatures::default())
+}
+
 pub(crate) fn clear(clear_type: ClearType) -> std::io::Result<()> {
     let screen_buffer = ScreenBuffer::current()?;
     let csbi = screen_buffer.info()?;