Terminal colors (#163)

* Use upstream versions of ratatui crates

* fmt

* Update deps again

* maybe we need to enable debug in mimalloc for windows?

* try to fix windows dll linking with mimalloc

* Update to latest version of mimalloc fork

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 - Added windows support! (thank you to [@jarjk](https://github.com/jarjk) for helping out!)
 - Added keybindings (`0`/`$`) to scroll to left or right side of zoomed-in image ([#131](https://github.com/itsjunetime/tdf/pull/131), thank you [@IshDeshpa](https://github.com/IshDeshpa)!)
+- Added `-t` flag to use terminal foreground/background colors in pdf rendering ([#138](https://github.com/itsjunetime/tdf/pull/138), thank you [@unorsk](https://github.com/unorsk)!
 - Fixed issue with images clearing/flashing after displaying a certain number on kitty
 - (Internal) decreased runtime footprint of tokio runtime
 

Cargo.toml

@@ -22,21 +22,16 @@ path = "src/main.rs"
 name = "tdf"
 
 [dependencies]
-# we're using this branch because it has significant performance fixes that I'm waiting on responses from the upstream devs to get upstreamed. See https://github.com/ratatui-org/ratatui/issues/1116
-ratatui = { git = "https://github.com/itsjunetime/ratatui.git", rev = "720ac2d0cad1ac6424364fea74856fec9c100cb1", default-features = false, features = [ "crossterm", "layout-cache" ] }
-# ratatui = { path = "./ratatui/ratatui/" }
-# We're using this to have the vb64 feature (for faster base64 encoding, since that does take up a good bit of time when converting images to the `Protocol`. It also just includes a few more features that I'm waiting on main to upstream
-ratatui-image = { git = "https://github.com/itsjunetime/ratatui-image.git", rev = "8ad154a219c1e4832a378bd07aaf39b3ddff959b", default-features = false }
-# ratatui-image = { path = "./ratatui-image", default-features = false }
+ratatui = { version = "^0.30.1", default-features = false, features = [ "crossterm", "layout-cache" ] }
+ratatui-image = { version = "11.0", default-features = false }
 crossterm = { version = "0.29.0", features = ["event-stream"] }
-# crossterm = { path = "../crossterm", features = ["event-stream"] }
 image = { version = "0.25.1", features = ["pnm", "rayon", "png"], default-features = false }
 notify = { version = "8.0.0", features = ["crossbeam-channel"] }
 tokio = { version = "1.37.0", features = ["rt-multi-thread", "macros"] }
 futures-util = { version = "0.3.30", default-features = false }
 flume = { version = "0.12.0", default-features = false, features = ["async"] }
 xflags = "0.4.0-pre.2"
-mimalloc = "0.1.43"
+mimalloc = { git = "https://github.com/itsjunetime/mimalloc_rust.git", rev = "1094dbf3afdc0a57215e925a05f2e3160e59575b", features = [ "debug_in_debug" ] }
 nix = { version = "0.31.0", features = ["signal"] }
 mupdf = { git = "https://github.com/messense/mupdf-rs.git", rev = "d7441b9998c92135e329559c0aa71d9dc92cf4de", default-features = false, features = ["svg", "system-fonts", "img"] }
 rayon = { version = "1", default-features = false }
@@ -54,9 +49,6 @@ flexi_logger = "0.31"
 # for tracing with tokio-console
 console-subscriber = { version = "0.5.0", optional = true }
 
-[patch.crates-io]
-pathfinder_simd = { git = "https://github.com/itsjunetime/pathfinder.git", rev = "814671e162a1829e074521446317b915311d3d4d" }
-
 [profile.production]
 inherits = "release"
 lto = "fat"

benches/utils.rs

@@ -4,7 +4,10 @@ use crossterm::terminal::WindowSize;
 use flume::{Sender, r#async::RecvStream, unbounded};
 use futures_util::stream::StreamExt as _;
 use ratatui::layout::Rect;
-use ratatui_image::picker::{Picker, ProtocolType};
+use ratatui_image::{
+	FontSize,
+	picker::{Picker, ProtocolType}
+};
 use tdf::{
 	converter::{ConvertedPage, ConverterMsg, run_conversion_loop},
 	renderer::{RenderError, RenderInfo, RenderNotif, fill_default, start_rendering}
@@ -54,7 +57,10 @@ pub struct RenderState {
 	pub to_render_tx: Sender<RenderNotif>
 }
 
-const FONT_SIZE: (u16, u16) = (8, 14);
+const FONT_SIZE: FontSize = FontSize {
+	width: 8,
+	height: 14
+};
 
 pub fn start_rendering_loop(
 	path: impl AsRef<Path>,
@@ -74,8 +80,8 @@ pub fn start_rendering_loop(
 	let size = WindowSize {
 		columns,
 		rows,
-		height: rows * FONT_SIZE.1,
-		width: columns * FONT_SIZE.0
+		height: rows * FONT_SIZE.height,
+		width: columns * FONT_SIZE.width
 	};
 
 	let main_area = Rect {

src/converter.rs

@@ -8,7 +8,7 @@ use flume::{Receiver, SendError, Sender, TryRecvError};
 use futures_util::stream::StreamExt as _;
 use image::{DynamicImage, codecs::pnm::PnmDecoder};
 use kittage::NumberOrId;
-use ratatui::layout::Rect;
+use ratatui::prelude::Size;
 use ratatui_image::{
 	Resize,
 	picker::{Picker, ProtocolType},
@@ -27,7 +27,7 @@ pub enum MaybeTransferred {
 	Transferred(kittage::ImageId)
 }
 
-#[derive(Debug)]
+// #[derive(Debug)]
 pub enum ConvertedImage {
 	Generic(Protocol),
 	Kitty {
@@ -42,8 +42,8 @@ impl ConvertedImage {
 	pub fn w_h(&self) -> (u16, u16) {
 		match self {
 			Self::Generic(prot) => {
-				let a = prot.area();
-				(a.width, a.height)
+				let Size { width, height } = prot.size();
+				(width, height)
 			}
 			Self::Kitty {
 				img: _,
@@ -72,7 +72,7 @@ pub async fn run_conversion_loop(
 	picker: Picker,
 	prerender: usize,
 	shms_work: bool
-) -> Result<(), SendError<Result<ConvertedPage, RenderError>>> {
+) -> Result<(), Box<SendError<Result<ConvertedPage, RenderError>>>> {
 	let mut images = vec![];
 	let mut page: usize = 0;
 	let pid = std::process::id();
@@ -134,11 +134,9 @@ pub async fn run_conversion_loop(
 				.for_each(|(_, _, px)| px.0[2] = px.0[2].saturating_sub(u8::MAX / 2));
 		}
 
-		let img_area = Rect {
+		let img_size = Size {
 			width: page_info.img_data.cell_w,
-			height: page_info.img_data.cell_h,
-			x: 0,
-			y: 0
+			height: page_info.img_data.cell_h
 		};
 
 		let dyn_img = DynamicImage::ImageRgb8(dyn_img);
@@ -174,7 +172,7 @@ pub async fn run_conversion_loop(
 			}
 			_ => ConvertedImage::Generic(
 				picker
-					.new_protocol(dyn_img, img_area, Resize::None)
+					.new_protocol(dyn_img, img_size, Resize::Crop(None))
 					.map_err(|e| {
 						RenderError::Converting(format!(
 							"Couldn't convert DynamicImage to ratatui image: {e}"

src/kitty.rs

@@ -1,8 +1,5 @@
 use core::fmt::Display;
-use std::{
-	io::{StdoutLock, Write, stdout},
-	num::NonZeroU32
-};
+use std::{io::Write, num::NonZeroU32};
 
 use crossterm::{
 	cursor::MoveTo,
@@ -18,8 +15,7 @@ use kittage::{
 	display::{CursorMovementPolicy, DisplayConfig, DisplayLocation},
 	error::TransmitError,
 	image::Image,
-	medium::Medium,
-	tmux::TmuxWriter
+	medium::Medium
 };
 use ratatui::layout::Position;
 use smallvec::SmallVec;
@@ -36,7 +32,7 @@ pub struct KittyReadyToDisplay<'tui> {
 pub enum KittyDisplay<'tui> {
 	NoChange,
 	ClearImages,
-	DisplayImages(SmallVec<[KittyReadyToDisplay<'tui>; 1]>)
+	DisplayImages(Vec<KittyReadyToDisplay<'tui>>)
 }
 
 pub struct DbgWriter<W: Write> {
@@ -66,58 +62,22 @@ impl<W: Write> Write for DbgWriter<W> {
 	}
 }
 
-pub enum MaybeTmuxWriter<W>
-where
-	W: Write
-{
-	Tmux(TmuxWriter<W>),
-	Normal(W)
-}
-
-impl<W: Write> MaybeTmuxWriter<W> {
-	pub fn new(w: W, is_tmux: bool) -> Self {
-		if is_tmux {
-			Self::Tmux(TmuxWriter::new(w))
-		} else {
-			Self::Normal(w)
-		}
-	}
-}
-
-impl<W: Write> Write for &mut MaybeTmuxWriter<W> {
-	fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-		match *self {
-			MaybeTmuxWriter::Tmux(t) => t.write(buf),
-			MaybeTmuxWriter::Normal(w) => w.write(buf)
-		}
-	}
-
-	fn flush(&mut self) -> std::io::Result<()> {
-		match *self {
-			MaybeTmuxWriter::Tmux(t) => t.flush(),
-			MaybeTmuxWriter::Normal(w) => w.flush()
-		}
-	}
-}
-
 pub async fn run_action<'es>(
 	action: Action<'_, '_>,
-	writer: &mut MaybeTmuxWriter<StdoutLock<'_>>,
 	ev_stream: &'es mut EventStream
 ) -> Result<Option<ImageId>, TransmitError<<&'es mut EventStream as AsyncInputReader>::Error>> {
 	let writer = DbgWriter {
-		w: writer,
+		w: std::io::stdout().lock(),
 		#[cfg(debug_assertions)]
 		buf: String::new()
 	};
-
 	action
 		.execute_async(writer, ev_stream)
 		.await
 		.map(|(_, i)| i)
 }
 
-pub async fn do_shms_work(is_tmux: bool, ev_stream: &mut EventStream) -> bool {
+pub async fn do_shms_work(ev_stream: &mut EventStream) -> bool {
 	let img = DynamicImage::new_rgb8(1, 1);
 	let pid = std::process::id();
 	let shm_name = format!("tdf_test_{pid}");
@@ -134,8 +94,7 @@ pub async fn do_shms_work(is_tmux: bool, ev_stream: &mut EventStream) -> bool {
 
 	enable_raw_mode().unwrap();
 
-	let mut writer = MaybeTmuxWriter::new(stdout().lock(), is_tmux);
-	let res = run_action(Action::Query(&k_img), &mut writer, ev_stream).await;
+	let res = run_action(Action::Query(&k_img), ev_stream).await;
 
 	disable_raw_mode().unwrap();
 
@@ -180,12 +139,9 @@ impl Display for DisplayErrSource<'_> {
 
 pub async fn display_kitty_images<'es>(
 	display: KittyDisplay<'_>,
-	is_tmux: bool,
 	ev_stream: &'es mut EventStream,
 	last_z_index: &mut i32
 ) -> Result<(), DisplayErr<'es>> {
-	let mut writer = MaybeTmuxWriter::new(stdout().lock(), is_tmux);
-
 	let images = match display {
 		KittyDisplay::NoChange => return Ok(()),
 		KittyDisplay::ClearImages =>
@@ -194,7 +150,6 @@ pub async fn display_kitty_images<'es>(
 					effect: ClearOrDelete::Clear,
 					which: WhichToDelete::All
 				}),
-				&mut writer,
 				ev_stream
 			)
 			.await
@@ -221,7 +176,7 @@ pub async fn display_kitty_images<'es>(
 			..DisplayConfig::default()
 		};
 
-		execute!(&mut writer, MoveTo(pos.x, pos.y)).unwrap();
+		execute!(std::io::stdout(), MoveTo(pos.x, pos.y)).unwrap();
 
 		log::debug!("going to display img {img:#?}");
 		log::debug!("displaying with config {config:#?}");
@@ -250,7 +205,6 @@ pub async fn display_kitty_images<'es>(
 						config,
 						placement_id: None
 					},
-					&mut writer,
 					ev_stream
 				)
 				.await
@@ -267,7 +221,6 @@ pub async fn display_kitty_images<'es>(
 					placement_id: *image_id,
 					config
 				},
-				&mut writer,
 				ev_stream
 			)
 			.await
@@ -300,7 +253,6 @@ pub async fn display_kitty_images<'es>(
 				effect: ClearOrDelete::Clear,
 				which: WhichToDelete::PlacementsWithZIndex(z_idxes_to_remove)
 			}),
-			&mut writer,
 			ev_stream
 		)
 		.await

src/main.rs

@@ -1,8 +1,11 @@
-use core::{error::Error, num::NonZeroUsize};
+use core::{
+	error::Error,
+	num::{NonZeroU32, NonZeroUsize}
+};
 use std::{
 	borrow::Cow,
 	ffi::OsString,
-	io::{BufReader, Read as _, Stdout, Write as _, stdout},
+	io::{BufReader, IsTerminal as _, Read as _, Stdout, Write as _, stdout},
 	mem,
 	path::PathBuf,
 	sync::{Arc, Mutex},
@@ -13,8 +16,8 @@ use crossterm::{
 	event::EventStream,
 	execute,
 	terminal::{
-		EndSynchronizedUpdate, EnterAlternateScreen, LeaveAlternateScreen, WindowSize,
-		disable_raw_mode, enable_raw_mode, window_size
+		EndSynchronizedUpdate, EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode,
+		enable_raw_mode, window_size
 	}
 };
 use debounce::EventDebouncer;
@@ -36,8 +39,7 @@ use tdf::{
 	PrerenderLimit,
 	converter::{ConvertedPage, ConverterMsg, run_conversion_loop},
 	kitty::{
-		DisplayErr, DisplayErrSource, KittyDisplay, MaybeTmuxWriter, display_kitty_images,
-		do_shms_work, run_action
+		DisplayErr, DisplayErrSource, KittyDisplay, display_kitty_images, do_shms_work, run_action
 	},
 	renderer::{self, MUPDF_BLACK, MUPDF_WHITE, RenderError, RenderInfo, RenderNotif},
 	tui::{BottomMessage, InputAction, MessageSetting, Tui}
@@ -114,6 +116,8 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		optional -w,--white-color white: String
 		/// Custom black color, specified in css format (e.g "000000" or "rgb(0, 0, 0)")
 		optional -b,--black-color black: String
+		/// Use terminal foreground/background colors for the PDF
+		optional -t,--terminal-colors
 		/// Print the version and exit
 		optional --version
 		/// PDF file to read
@@ -135,37 +139,49 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		.canonicalize()
 		.map_err(|e| WrappedErr(format!("Cannot canonicalize provided file: {e}").into()))?;
 
-	let black = flags
-		.black_color
-		.as_deref()
-		.map(|color| {
-			parse_color_to_i32(color).map_err(|e| {
-				WrappedErr(
-					format!(
-						"Couldn't parse black color {color:?}: {e} - is it formatted like a CSS color?"
-					)
-					.into()
-				)
-			})
-		})
-		.transpose()?
-		.unwrap_or(MUPDF_BLACK);
+	if flags.terminal_colors && (flags.black_color.is_some() || flags.white_color.is_some()) {
+		return Err(WrappedErr(
+			"--terminal-colors cannot be combined with --black-color or --white-color".into()
+		));
+	}
 
-	let white = flags
-		.white_color
-		.as_deref()
-		.map(|color| {
-			parse_color_to_i32(color).map_err(|e| {
-				WrappedErr(
-					format!(
-						"Couldn't parse white color {color:?}: {e} - is it formatted like a CSS color?"
+	let (black, white) = if flags.terminal_colors {
+		query_terminal_colors()
+	} else {
+		let black = flags
+			.black_color
+			.as_deref()
+			.map(|color| {
+				parse_color_to_i32(color).map_err(|e| {
+					WrappedErr(
+						format!(
+							"Couldn't parse black color {color:?}: {e} - is it formatted like a CSS color?"
+						)
+						.into()
 					)
-					.into()
-				)
+				})
 			})
-		})
-		.transpose()?
-		.unwrap_or(MUPDF_WHITE);
+			.transpose()?
+			.unwrap_or(MUPDF_BLACK);
+
+		let white = flags
+			.white_color
+			.as_deref()
+			.map(|color| {
+				parse_color_to_i32(color).map_err(|e| {
+					WrappedErr(
+						format!(
+							"Couldn't parse white color {color:?}: {e} - is it formatted like a CSS color?"
+						)
+						.into()
+					)
+				})
+			})
+			.transpose()?
+			.unwrap_or(MUPDF_WHITE);
+
+		(black, white)
+	};
 
 	// need to keep it around throughout the lifetime of the program, but don't rly need to use it.
 	// Just need to make sure it doesn't get dropped yet.
@@ -248,20 +264,22 @@ async fn inner_main() -> Result<(), WrappedErr> {
 	// We need to create `picker` on this thread because if we create it on the `renderer` thread,
 	// it messes up something with user input. Input never makes it to the crossterm thing
 	let picker = Picker::from_query_stdio()
-		.or_else(|e| match (e, window_size) {
-			(
-				ratatui_image::errors::Errors::NoFontSize,
-				WindowSize { width: 1.., height: 1.., columns: 1.., rows: 1.. }
-			) => {
+		.or_else(|e| match e {
+			ratatui_image::errors::Errors::NoFontSize if
+				window_size.width != 0
+				&& window_size.height != 0
+				&& window_size.columns != 0
+				&& window_size.rows != 0 =>
+			{
 				// the 'equivalent' that is suggested instead is not the same. We need to keep
 				// calling this.
 				#[expect(deprecated)]
-				Ok(Picker::from_fontsize((cell_width_px, cell_height_px)))
+				Ok(Picker::from_fontsize(FontSize { width: cell_width_px, height: cell_height_px }))
 			},
-			(ratatui_image::errors::Errors::NoFontSize, _) => Err(WrappedErr(
+			ratatui_image::errors::Errors::NoFontSize => Err(WrappedErr(
 				"Unable to detect your terminal's font size; this is an issue with your terminal emulator.\nPlease use a different terminal emulator or report this bug to tdf.".into()
 			)),
-			(e, _) => Err(WrappedErr(format!("Couldn't get the necessary information to set up images: {e}").into()))
+			e => Err(WrappedErr(format!("Couldn't get the necessary information to set up images: {e}").into()))
 		})?;
 
 	// then we want to spawn off the rendering task
@@ -294,9 +312,8 @@ async fn inner_main() -> Result<(), WrappedErr> {
 	let (to_main, from_converter) = flume::unbounded();
 
 	let is_kitty = picker.protocol_type() == ProtocolType::Kitty;
-	let is_tmux = picker.is_tmux();
 
-	let shms_work = is_kitty && do_shms_work(is_tmux, &mut ev_stream).await;
+	let shms_work = is_kitty && do_shms_work(&mut ev_stream).await;
 
 	tokio::spawn(run_conversion_loop(
 		to_main, from_main, picker, 20, shms_work
@@ -312,7 +329,7 @@ async fn inner_main() -> Result<(), WrappedErr> {
 	let mut term = Terminal::new(backend).map_err(|e| {
 		WrappedErr(format!("Couldn't set up crossterm's terminal backend: {e}").into())
 	})?;
-	term.skip_diff(true);
+	// term.skip_diff(true);
 
 	enable_raw_mode().map_err(|e| {
 		WrappedErr(
@@ -321,13 +338,11 @@ async fn inner_main() -> Result<(), WrappedErr> {
 	})?;
 
 	if is_kitty {
-		let mut writer = MaybeTmuxWriter::new(stdout().lock(), is_tmux);
 		run_action(
 			Action::Delete(DeleteConfig {
 				effect: ClearOrDelete::Delete,
-				which: WhichToDelete::All
+				which: WhichToDelete::IdRange(NonZeroU32::new(1).unwrap()..=NonZeroU32::MAX)
 			}),
-			&mut writer,
 			&mut ev_stream
 		)
 		.await
@@ -349,14 +364,13 @@ async fn inner_main() -> Result<(), WrappedErr> {
 	let tui_rx = tui_rx.into_stream();
 	let from_converter = from_converter.into_stream();
 
-	let res = enter_redraw_loop(
-		&mut ev_stream,
+	enter_redraw_loop(
+		ev_stream,
 		to_renderer,
 		tui_rx,
 		to_converter,
 		from_converter,
 		fullscreen,
-		is_tmux,
 		tui,
 		&mut term,
 		main_area,
@@ -370,35 +384,21 @@ async fn inner_main() -> Result<(), WrappedErr> {
 			)
 			.into()
 		)
-	});
+	})?;
 
-	if is_kitty {
-		let mut writer = MaybeTmuxWriter::new(stdout().lock(), is_tmux);
-		_ = run_action(
-			Action::Delete(DeleteConfig {
-				effect: ClearOrDelete::Delete,
-				which: WhichToDelete::All
-			}),
-			&mut writer,
-			&mut ev_stream
-		)
-		.await;
-	}
 	drop(maybe_logger);
-
-	res
+	Ok(())
 }
 
 // oh shut up clippy who cares
 #[expect(clippy::too_many_arguments)]
 async fn enter_redraw_loop(
-	ev_stream: &mut EventStream,
+	mut ev_stream: EventStream,
 	to_renderer: Sender<RenderNotif>,
 	mut tui_rx: RecvStream<'_, Result<RenderInfo, RenderError>>,
 	to_converter: Sender<ConverterMsg>,
 	mut from_converter: RecvStream<'_, Result<ConvertedPage, RenderError>>,
 	mut fullscreen: bool,
-	is_tmux: bool,
 	mut tui: Tui,
 	term: &mut Terminal<CrosstermBackend<Stdout>>,
 	mut main_area: tdf::tui::RenderLayout,
@@ -479,7 +479,7 @@ async fn enter_redraw_loop(
 			})?;
 
 			let maybe_err =
-				display_kitty_images(to_display, is_tmux, ev_stream, &mut kitty_z_idx).await;
+				display_kitty_images(to_display, &mut ev_stream, &mut kitty_z_idx).await;
 
 			if let Err(DisplayErr {
 				failed_pages,
@@ -579,6 +579,89 @@ fn parse_color_to_i32(cs: &str) -> Result<i32, csscolorparser::ParseColorError>
 	Ok(i32::from_be_bytes([0, r, g, b]))
 }
 
+fn query_terminal_colors() -> (i32, i32) {
+	if !std::io::stdin().is_terminal() || !std::io::stdout().is_terminal() {
+		return (MUPDF_BLACK, MUPDF_WHITE);
+	}
+
+	let Ok(()) = enable_raw_mode() else {
+		return (MUPDF_BLACK, MUPDF_WHITE);
+	};
+
+	struct RawModeGuard;
+	impl Drop for RawModeGuard {
+		fn drop(&mut self) {
+			let _ = disable_raw_mode();
+		}
+	}
+	let _guard = RawModeGuard;
+
+	let stdin = std::io::stdin();
+	let mut handle = stdin.lock();
+
+	let fg = query_osc_color(10, &mut handle);
+	let bg = query_osc_color(11, &mut handle);
+	drop(handle);
+
+	(fg.unwrap_or(MUPDF_BLACK), bg.unwrap_or(MUPDF_WHITE))
+}
+
+fn query_osc_color(osc: u8, handle: &mut std::io::StdinLock<'_>) -> Option<i32> {
+	print!("\x1b]{osc};?\x1b\\");
+	std::io::stdout().flush().ok()?;
+
+	// response looks like "\u{1b}]10;rgb:rrrr/bbbb/gggg\u{1b}\\" or "\u{1b}]10;rgb:rr/bb/gg\u{1b}\\"
+	// or if osc is 11, "\u{1b}]11;rgb:rrrr/bbbb/gggg\u{1b}\\" or "\u{1b}]11;rgb:rr/bb/gg\u{1b}\\"
+
+	// We expect the response to be either 19 or 25 bytes.
+	let mut response_buf = [0u8; 25];
+
+	handle.read_exact(&mut response_buf[..19])
+		.inspect_err(|e| eprintln!("Couldn't get a response from your terminal for querying OSC {osc}; please file a bug with tdf with your terminal emulator (underlying err: {e})"))
+		.ok()?;
+
+	let two_digit_colors = response_buf[11] == b'/';
+
+	if !two_digit_colors {
+		handle.read_exact(&mut response_buf[19..])
+			.inspect_err(|e| eprintln!("Couldn't get a response from your terminal for querying OSC {osc}; please file a bug with tdf with your terminal emulator (underlying err: {e})"))
+			.ok()?;
+	}
+
+	osc_response_buf_to_color(response_buf)
+}
+
+fn osc_response_buf_to_color(response_buf: [u8; 25]) -> Option<i32> {
+	fn parse(ascii_hex_bytes: &[u8]) -> Option<u8> {
+		let mut color = 0;
+
+		for byte in ascii_hex_bytes {
+			color = (color << 4)
+				+ (match byte {
+					b'0'..=b'9' => byte - b'0',
+					b'A'..=b'F' => byte - (b'A' - 10),
+					b'a'..=b'f' => byte - (b'a' - 10),
+					_ => return None
+				});
+		}
+
+		Some(color)
+	}
+
+	let two_digit_colors = response_buf[11] == b'/';
+
+	// this is minimimal validation.
+	// the response either has `rrrr/gggg/bbbb` or `rr/gg/bb` starting at byte 9.
+	// So we grab the first two digits out of the r, g, and b sections (since we can only support
+	// 8-bit colors with mupdf; we can't do the 16-bits that the terminal might respond with), we
+	// parse them, and we return it as an i32.
+	let r = parse(&response_buf[9..11])?;
+	let g = parse(&response_buf[if two_digit_colors { 12..14 } else { 14..16 }])?;
+	let b = parse(&response_buf[if two_digit_colors { 15..17 } else { 19..21 }])?;
+
+	Some(i32::from_be_bytes([0, r, g, b]))
+}
+
 fn get_font_size_through_stdio() -> Result<(u16, u16), WrappedErr> {
 	// send the command code to get the terminal window size
 	print!("\x1b[14t");
@@ -645,3 +728,19 @@ fn get_font_size_through_stdio() -> Result<(u16, u16), WrappedErr> {
 
 	Ok((w, h))
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn osc_response_parsing() {
+		fn eq(bytes: [u8; 25], r: u8, g: u8, b: u8) {
+			let resp = osc_response_buf_to_color(bytes);
+			assert_eq!(resp, Some(i32::from_be_bytes([0, r, g, b])));
+		}
+
+		eq(*b"\x1b]10;rgb:11/22/33\x1b\\000000", 0x11, 0x22, 0x33);
+		eq(*b"\x1b]11;rgb:aa11/23bf/fff0\x1b1", 0xaa, 0x23, 0xff);
+	}
+}

src/skip.rs

@@ -1,23 +1,14 @@
 use std::num::NonZeroUsize;
 
-use ratatui::widgets::Widget;
+use ratatui::{prelude::buffer::CellDiffOption, widgets::Widget};
 
-pub struct Skip {
-	skip: bool
-}
-
-impl Skip {
-	#[must_use]
-	pub fn new(skip: bool) -> Self {
-		Self { skip }
-	}
-}
+pub struct Skip;
 
 impl Widget for Skip {
 	fn render(self, area: ratatui::prelude::Rect, buf: &mut ratatui::prelude::Buffer) {
 		for x in area.x..(area.x + area.width) {
 			for y in area.y..(area.y + area.height) {
-				buf[(x, y)].skip = self.skip;
+				buf[(x, y)].diff_option = CellDiffOption::Skip;
 			}
 		}
 	}

src/tui.rs

@@ -19,7 +19,6 @@ use ratatui::{
 	widgets::{Block, Borders, Clear, Padding, Paragraph, Wrap}
 };
 use ratatui_image::{FontSize, Image};
-use smallvec::SmallVec;
 
 use crate::{
 	FitOrFill,
@@ -350,8 +349,8 @@ impl Tui {
 			}
 		}
 
-		let width = (img_section_w * f32::from(font_size.0)) as u32;
-		let height = (img_section_h * f32::from(font_size.1)) as u32;
+		let width = (img_section_w * f32::from(font_size.width)) as u32;
+		let height = (img_section_h * f32::from(font_size.height)) as u32;
 
 		zoom.cell_pan_from_left = zoom
 			.cell_pan_from_left
@@ -360,7 +359,7 @@ impl Tui {
 			.cell_pan_from_top
 			.min(img_cell_h.saturating_sub(img_section_h.ceil() as u16));
 
-		KittyDisplay::DisplayImages(SmallVec::from([KittyReadyToDisplay {
+		KittyDisplay::DisplayImages(vec![KittyReadyToDisplay {
 			img,
 			page_num,
 			pos: Position {
@@ -368,15 +367,15 @@ impl Tui {
 				y: img_area.y
 			},
 			display_loc: DisplayLocation {
-				x: u32::from(zoom.cell_pan_from_left) * u32::from(font_size.0),
-				y: u32::from(zoom.cell_pan_from_top) * u32::from(font_size.1),
+				x: u32::from(zoom.cell_pan_from_left) * u32::from(font_size.width),
+				y: u32::from(zoom.cell_pan_from_top) * u32::from(font_size.height),
 				width,
 				height,
 				columns: img_area.width,
 				rows: img_area.height,
 				..DisplayLocation::default()
 			}
-		}]))
+		}])
 	}
 
 	#[must_use]
@@ -410,7 +409,7 @@ impl Tui {
 			// resize this time), then go through every element in the buffer where any Image would
 			// be written and set to skip it so that ratatui doesn't spend a lot of time diffing it
 			// each re-render
-			frame.render_widget(Skip::new(true), img_area);
+			frame.render_widget(Skip, img_area);
 			return KittyDisplay::NoChange;
 		}
 
@@ -518,7 +517,7 @@ impl Tui {
 						display_loc: DisplayLocation::default()
 					})
 				})
-				.collect::<SmallVec<_>>();
+				.collect::<Vec<_>>();
 
 			// we want to set this at the very end so it doesn't get set somewhere halfway through and
 			// then the whole diffing thing messes it up
@@ -740,19 +739,19 @@ impl Tui {
 						InputAction::Redraw.into()
 					}
 					KeyCode::Char(c)
-						if let BottomMessage::Input(InputCommand::GoToPage(ref mut page)) =
-							self.bottom_msg && matches!(c, 'g' if self.is_kitty) =>
-						c.to_digit(10).map(|input_num| {
-							*page = (*page * 10) + input_num as usize;
-							InputAction::Redraw
-						}),
-					KeyCode::Char(_)
 						if let BottomMessage::Input(InputCommand::GoToPage(_)) =
-							self.bottom_msg =>
+							self.bottom_msg && matches!(c, 'g' if self.is_kitty) =>
 					{
 						self.set_msg(MessageSetting::Pop);
 						self.update_zoom(Zoom::pan_bottom)
 					}
+					KeyCode::Char(c)
+						if let BottomMessage::Input(InputCommand::GoToPage(ref mut page)) =
+							self.bottom_msg =>
+						c.to_digit(10).map(|input_num| {
+							*page = (*page * 10) + input_num as usize;
+							InputAction::Redraw
+						}),
 					KeyCode::Char(c) => match c {
 						'l' => self.change_page(PageChange::Next, ChangeAmount::Single),
 						'j' => self.change_page(PageChange::Next, ChangeAmount::WholeScreen),