#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum Background {
#[default]
Unknown,
Dark,
Light,
}
pub fn from_env() -> Background {
std::env::var("COLORFGBG")
.ok()
.as_deref()
.map_or(Background::Unknown, from_colorfgbg)
}
fn from_colorfgbg(value: &str) -> Background {
if !value.contains(';') {
return Background::Unknown;
}
let Some(field) = value.rsplit(';').next() else {
return Background::Unknown;
};
match field.trim().parse::<u8>() {
Ok(7) | Ok(9..=15) => Background::Light,
Ok(0..=6) | Ok(8) => Background::Dark,
Ok(_) | Err(_) => Background::Unknown,
}
}
#[cfg(feature = "background-probe")]
fn from_rgb(red: u8, green: u8, blue: u8) -> Background {
let luminance = 0.2126 * f32::from(red) + 0.7152 * f32::from(green) + 0.0722 * f32::from(blue);
if luminance > 127.5 {
Background::Light
} else {
Background::Dark
}
}
#[cfg(feature = "background-probe")]
pub use probe_impl::probe;
#[cfg(feature = "background-probe")]
mod probe_impl {
use std::time::Duration;
use super::{Background, from_env, from_rgb};
pub fn probe(timeout: Duration) -> Background {
match from_env() {
Background::Unknown => query(timeout),
known => known,
}
}
#[cfg(not(unix))]
fn query(_timeout: Duration) -> Background {
Background::Unknown
}
#[cfg(unix)]
fn query(timeout: Duration) -> Background {
use std::fs::OpenOptions;
use std::io::{Read, Write};
use std::os::fd::AsRawFd;
const QUERY: &[u8] = b"\x1b]11;?\x1b\\";
let Ok(mut tty) = OpenOptions::new().read(true).write(true).open("/dev/tty") else {
return Background::Unknown;
};
let fd = tty.as_raw_fd();
let Some(raw) = RawMode::enter(fd) else {
return Background::Unknown;
};
if tty.write_all(QUERY).is_err() || tty.flush().is_err() {
drop(raw);
return Background::Unknown;
}
let mut reply = Vec::new();
let mut byte = [0u8; 1];
let deadline = std::time::Instant::now() + timeout;
let background = loop {
let remaining = deadline.saturating_duration_since(std::time::Instant::now());
if remaining.is_zero() || !readable(fd, remaining) {
break Background::Unknown;
}
match tty.read(&mut byte) {
Ok(1) => {}
Ok(_) | Err(_) => break Background::Unknown,
}
if matches!(byte[0], 0x07 | b'\\') {
break parse_reply(&reply);
}
reply.push(byte[0]);
if reply.len() > 64 {
break Background::Unknown;
}
};
drop(raw);
background
}
#[cfg_attr(test, allow(clippy::missing_const_for_fn))]
fn parse_reply(reply: &[u8]) -> Background {
let Ok(text) = std::str::from_utf8(reply) else {
return Background::Unknown;
};
let Some(spec) = text.split_once("rgb:").map(|(_, rest)| rest) else {
return Background::Unknown;
};
let mut components = spec.trim().split('/');
let (Some(red), Some(green), Some(blue), None) = (
components.next(),
components.next(),
components.next(),
components.next(),
) else {
return Background::Unknown;
};
let (Some(red), Some(green), Some(blue)) = (
scale_component(red),
scale_component(green),
scale_component(blue),
) else {
return Background::Unknown;
};
from_rgb(red, green, blue)
}
fn scale_component(value: &str) -> Option<u8> {
let digits = u32::try_from(value.len()).ok()?;
if !(1..=4).contains(&digits) {
return None;
}
let parsed = u32::from_str_radix(value, 16).ok()?;
let full = (1u32 << (digits * 4)) - 1;
u8::try_from(parsed.min(full) * 255 / full).ok()
}
#[cfg(unix)]
fn readable(fd: std::os::fd::RawFd, timeout: std::time::Duration) -> bool {
let mut poll = libc::pollfd {
fd,
events: libc::POLLIN,
revents: 0,
};
let millis = i32::try_from(timeout.as_millis()).unwrap_or(i32::MAX);
unsafe { libc::poll(&raw mut poll, 1, millis) == 1 }
}
#[cfg(unix)]
struct RawMode {
fd: std::os::fd::RawFd,
saved: libc::termios,
}
#[cfg(unix)]
impl RawMode {
fn enter(fd: std::os::fd::RawFd) -> Option<Self> {
let mut saved: libc::termios = unsafe { std::mem::zeroed() };
if unsafe { libc::tcgetattr(fd, &raw mut saved) } != 0 {
return None;
}
let mut raw = saved;
raw.c_lflag &= !(libc::ICANON | libc::ECHO);
if unsafe { libc::tcsetattr(fd, libc::TCSANOW, &raw const raw) } != 0 {
return None;
}
Some(Self { fd, saved })
}
}
#[cfg(unix)]
impl Drop for RawMode {
fn drop(&mut self) {
unsafe { libc::tcsetattr(self.fd, libc::TCSANOW, &raw const self.saved) };
}
}
#[cfg(test)]
mod tests {
use super::{Background, parse_reply, scale_component};
#[test]
fn parses_four_digit_components() {
assert_eq!(
parse_reply(b"]11;rgb:0000/0000/0000"),
Background::Dark,
"black background"
);
assert_eq!(
parse_reply(b"]11;rgb:ffff/ffff/ffff"),
Background::Light,
"white background"
);
}
#[test]
fn component_width_does_not_change_the_value() {
assert_eq!(scale_component("f"), Some(255));
assert_eq!(scale_component("ff"), Some(255));
assert_eq!(scale_component("ffff"), Some(255));
assert_eq!(scale_component("0"), Some(0));
assert_eq!(scale_component("8080"), Some(128));
}
#[test]
fn malformed_replies_are_unknown() {
for reply in [
&b"]11;rgb:0000/0000"[..],
&b"]11;rgb:0000/0000/0000/0000"[..],
&b"]11;0000/0000/0000"[..],
&b"]11;rgb:zzzz/0000/0000"[..],
&b"]11;rgb:00000/0/0"[..],
&b""[..],
] {
assert_eq!(
parse_reply(reply),
Background::Unknown,
"{}",
String::from_utf8_lossy(reply)
);
}
}
#[test]
fn solarized_light_reads_as_light_and_dark_as_dark() {
assert_eq!(parse_reply(b"]11;rgb:fd/f6/e3"), Background::Light);
assert_eq!(parse_reply(b"]11;rgb:00/2b/36"), Background::Dark);
}
}
}
#[cfg(test)]
mod tests {
use super::{Background, from_colorfgbg};
#[test]
fn colorfgbg_background_is_the_last_field() {
assert_eq!(from_colorfgbg("15;0"), Background::Dark);
assert_eq!(from_colorfgbg("0;15"), Background::Light);
assert_eq!(from_colorfgbg("15;default;0"), Background::Dark);
assert_eq!(from_colorfgbg("0;default;7"), Background::Light);
}
#[test]
fn colorfgbg_without_a_background_field_is_unknown() {
assert_eq!(from_colorfgbg("15"), Background::Unknown);
assert_eq!(from_colorfgbg(""), Background::Unknown);
assert_eq!(from_colorfgbg("15;default"), Background::Unknown);
assert_eq!(from_colorfgbg("15;255"), Background::Unknown);
}
#[cfg(feature = "background-probe")]
#[test]
fn luminance_is_weighted_not_averaged() {
assert_eq!(super::from_rgb(0, 255, 0), Background::Light);
assert_eq!(super::from_rgb(0, 0, 255), Background::Dark);
}
}