-//! terminal outputs

-//! produces output for any terminal supporting one of the

-//! ```text

-//! Kitty Graphics Protocol

-//! Iterm2 Inline Image Protocol

-//! Sixel Bitmap Graphics Format

-//! ```

-//! with a fallback for dumb terminals.

-//!

-//! the (second?) best way to debug your images.

-mod bloc;

-mod kitty;

-mod sixel;

-mod size;

-use crate::Image;

-pub use bloc::Bloc;

-pub use iterm2::Iterm2;

-pub use kitty::Kitty;

-pub use sixel::Sixel;

-use std::fmt::{Result, Write};

-

-mod seal {

- pub trait Sealed {}

-}

-use seal::Sealed;

-#[doc(hidden)]

-pub trait Basic: Sealed {}

-impl Sealed for [(); 1] {}

-impl Basic for [(); 1] {}

-impl Sealed for [(); 2] {}

-impl Basic for [(); 2] {}

-impl Sealed for [(); 3] {}

-impl Basic for [(); 3] {}

-impl Sealed for [(); 4] {}

-impl Basic for [(); 4] {}

-

-mod b64;

-mod iterm2;

-

-impl<'a, const N: usize> std::fmt::Display for Image<&'a [u8], N>

-where

- [(); N]: Basic,

-{

- /// Display an image in the terminal.

- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result {

- Display(*self).write(f)

- }

-}

-

-/// Print an image in the terminal.

-///

-/// This is a wrapper for `print!("{}", term::Display(image))`

-pub fn print<T: AsRef<[u8]>, const N: usize>(i: Image<T, N>)

-where

- [(); N]: Basic,

- Display<Image<T, N>>: std::fmt::Display,

-{

- print!("{}", Display(i))

-}

-

-#[derive(Copy, Clone)]

-/// Display an image in the terminal.

-/// This type implements [`Display`](std::fmt::Display) and [`Debug`](std::fmt::Debug).

-pub struct Display<T>(pub T);

-

-impl<T> std::ops::Deref for Display<T> {

- type Target = T;

-

- fn deref(&self) -> &Self::Target {

- &self.0

- }

-}

-

-impl<T: AsRef<[u8]>, const N: usize> std::fmt::Debug for Display<Image<T, N>>

-where

- [(); N]: Basic,

-{

- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result {

- Display(self.as_ref()).write(f)

- }

-}

-

-impl<const N: usize> Display<Image<&[u8], N>>

-where

- [(); N]: Basic,

-{

- /// Write $TERM protocol encoded image data.

- pub fn write(self, f: &mut impl Write) -> Result {

- if let Ok(term) = std::env::var("TERM") {

- match &*term {

- "mlterm" | "yaft-256color" => return Sixel(self.0).write(f),

- x if x.contains("kitty") => return Kitty(self.0).write(f),

- _ => (),

- }

- }

- if let Ok(term_program) = std::env::var("TERM_PROGRAM") {

- match &*term_program {

- "MacTerm" => return Sixel(self.0).write(f),

- "iTerm" | "WezTerm" => return Iterm2(self.0).write(f),

- _ => (),

- }

- }

- if let Ok("iTerm") = std::env::var("LC_TERMINAL").as_deref() {

- return Iterm2(self.0).write(f);

- }

- #[cfg(unix)]

- return self

- .guess_harder(f)

- .unwrap_or_else(|| Bloc(self.0).write(f));

- #[cfg(not(unix))]

- return Bloc(*self).write(f);

- }

-

- #[cfg(unix)]

- // https://github.com/benjajaja/ratatui-image/blob/eeb2a1b26fbe360259f213d6d5eb5449c8ae1d6e/src/picker.rs#L226

- fn guess_harder(&self, to: &mut impl Write) -> Option<Result> {

- // contains a kitty gfx and sixel query, the `\x1b[c` is for sixels

- let buf = query(r"_Gi=31,s=1,v=1,a=q,t=d,f=24;AAAA\")?;

- if buf.contains("_Gi=31;OK") {

- Some(Kitty(self.as_ref()).write(to))

- } else if buf.contains(";4;")

- || buf.contains("?4;")

- || buf.contains(";4c")

- || buf.contains("?4c")

- {

- Some(Sixel(self.as_ref()).write(to))

- } else {

- None

- }

- }

-}

-#[cfg(not(unix))]

-fn query(device_query_code: &'static str) -> Option<String> {

- None

-}

-#[cfg(unix)]

-// https://github.com/benjajaja/ratatui-image/blob/master/src/picker.rs#L226

-fn query(device_query_code: &'static str) -> Option<String> {

- extern crate libc;

- use std::mem::MaybeUninit;

- fn r(result: i32) -> Option<()> {

- (result != -1).then_some(())

- }

-

- let mut termios = MaybeUninit::<libc::termios>::uninit();

- // SAFETY: get termios of stdin

- r(unsafe { libc::tcgetattr(0, termios.as_mut_ptr()) })?;

- // SAFETY: gotten

- let termios = unsafe { termios.assume_init() };

-

- // SAFETY: turn off echo and canonical (requires enter before stdin reads) modes

- unsafe {

- libc::tcsetattr(

- 0,

- libc::TCSADRAIN,

- &libc::termios {

- c_lflag: termios.c_lflag & !libc::ICANON & !libc::ECHO,

- ..termios

- },

- )

- };

-

- let buf = try {

- // SAFETY: linux time out'd reading

- unsafe {

- println!("{device_query_code}");

- let mut buf = Vec::new();

- let mut tmp = [0; 1 << 5];

- loop {

- let mut x: libc::fd_set = std::mem::zeroed::<libc::fd_set>();

- libc::FD_SET(0, &mut x);

- match libc::select(

- 1,

- &mut x,

- 0 as _,

- 0 as _,

- &mut libc::timeval {

- tv_sec: 0,

- tv_usec: 5e5 as _,

- },

- ) {

- 0 => break,

- -1 => return None,

- _ => {}

- }

- match libc::read(libc::STDIN_FILENO, tmp.as_mut_ptr().cast(), tmp.len()) {

- 0 => continue,

- -1 => return None,

- n => buf.extend_from_slice(&tmp[..n as _]),

- }

- }

- String::from_utf8(buf).ok()?

- }

- };

-

- // SAFETY: reset attrs to what they were before we became nosy

- unsafe { libc::tcsetattr(0, libc::TCSADRAIN, &termios) };

- buf

-}