fmt

* fix 'g' keybinding after if-let-arms refactor

* box error

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 - 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
 
 # v0.5.0

Cargo.lock

@@ -1573,9 +1573,9 @@ checksum = "7a79a3332a6609480d7d0c9eab957bca6b455b91bb84e66d19f5ff66294b85b8"
 
 [[package]]
 name = "libc"
-version = "0.2.185"
+version = "0.2.186"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52ff2c0fe9bc6cb6b14a0592c2ff4fa9ceb83eea9db979b0487cd054946a2b8f"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 
 [[package]]
 name = "libfuzzer-sys"
@@ -1605,12 +1605,11 @@ checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
 
 [[package]]
 name = "libmimalloc-sys"
-version = "0.1.44"
+version = "0.1.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "667f4fec20f29dfc6bc7357c582d91796c169ad7e2fce709468aefeb2c099870"
+checksum = "2d1eacfa31c33ec25e873c136ba5669f00f9866d0688bea7be4d3f7e43067df6"
 dependencies = [
  "cc",
- "libc",
 ]
 
 [[package]]
@@ -1727,9 +1726,9 @@ dependencies = [
 
 [[package]]
 name = "mimalloc"
-version = "0.1.48"
+version = "0.1.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1ee66a4b64c74f4ef288bcbb9192ad9c3feaad75193129ac8509af543894fd8"
+checksum = "b3627c4272df786b9260cabaa46aec1d59c93ede723d4c3ef646c503816b0640"
 dependencies = [
  "libmimalloc-sys",
 ]
@@ -2081,7 +2080,7 @@ dependencies = [
 [[package]]
 name = "pathfinder_simd"
 version = "0.5.5"
-source = "git+https://github.com/itsjunetime/pathfinder.git?branch=fix_nightly_arm_simd#814671e162a1829e074521446317b915311d3d4d"
+source = "git+https://github.com/itsjunetime/pathfinder.git?rev=814671e162a1829e074521446317b915311d3d4d#814671e162a1829e074521446317b915311d3d4d"
 dependencies = [
  "rustc_version",
 ]

Cargo.toml

@@ -55,7 +55,7 @@ flexi_logger = "0.31"
 console-subscriber = { version = "0.5.0", optional = true }
 
 [patch.crates-io]
-pathfinder_simd = { git = "https://github.com/itsjunetime/pathfinder.git", branch = "fix_nightly_arm_simd" }
+pathfinder_simd = { git = "https://github.com/itsjunetime/pathfinder.git", rev = "814671e162a1829e074521446317b915311d3d4d" }
 
 [profile.production]
 inherits = "release"

src/converter.rs

@@ -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();

src/kitty.rs

@@ -139,12 +139,13 @@ impl Display for DisplayErrSource<'_> {
 
 pub async fn display_kitty_images<'es>(
 	display: KittyDisplay<'_>,
-	ev_stream: &'es mut EventStream
+	ev_stream: &'es mut EventStream,
+	last_z_index: &mut i32
 ) -> Result<(), DisplayErr<'es>> {
 	let images = match display {
 		KittyDisplay::NoChange => return Ok(()),
-		KittyDisplay::DisplayImages(_) | KittyDisplay::ClearImages => {
-			run_action(
+		KittyDisplay::ClearImages =>
+			return run_action(
 				Action::Delete(DeleteConfig {
 					effect: ClearOrDelete::Clear,
 					which: WhichToDelete::All
@@ -152,24 +153,23 @@ pub async fn display_kitty_images<'es>(
 				ev_stream
 			)
 			.await
-			.map_err(|e| DisplayErr::empty("Couldn't clear previous images", e))?;
-
-			let KittyDisplay::DisplayImages(images) = display else {
-				return Ok(());
-			};
-
-			images
-		}
+			.map_err(|e| DisplayErr::empty("Couldn't clear previous images", e))
+			.map(|_: Option<ImageId>| ()),
+		KittyDisplay::DisplayImages(imgs) => imgs
 	};
 
+	let new_z_index = last_z_index.wrapping_add_unsigned(1);
+
 	let mut err = Ok::<(), (SmallVec<[usize; 2]>, DisplayErrSource<'es>)>(());
 	for KittyReadyToDisplay {
 		img,
 		page_num,
 		pos,
-		display_loc
+		mut display_loc
 	} in images
 	{
+		display_loc.z_index = new_z_index;
+
 		let config = DisplayConfig {
 			location: display_loc,
 			cursor_movement: CursorMovementPolicy::DontMove,
@@ -199,7 +199,7 @@ pub async fn display_kitty_images<'es>(
 				};
 				std::mem::swap(image, &mut fake_image);
 
-				let res = run_action(
+				run_action(
 					Action::TransmitAndDisplay {
 						image: fake_image,
 						config,
@@ -207,16 +207,13 @@ pub async fn display_kitty_images<'es>(
 					},
 					ev_stream
 				)
-				.await;
-
-				match res {
-					Ok(Some(img_id)) => {
-						*img = MaybeTransferred::Transferred(img_id);
-						Ok(())
-					}
-					Ok(None) => Err((page_num, DisplayErrSource::KittageReturnedNoId)),
-					Err(e) => Err((page_num, DisplayErrSource::Transmission(e)))
-				}
+				.await
+				.map_err(DisplayErrSource::Transmission)
+				.and_then(|img_id| {
+					img_id
+						.map(|id| *img = MaybeTransferred::Transferred(id))
+						.ok_or(DisplayErrSource::KittageReturnedNoId)
+				})
 			}
 			MaybeTransferred::Transferred(image_id) => run_action(
 				Action::Display {
@@ -229,22 +226,37 @@ pub async fn display_kitty_images<'es>(
 			.await
 			// don't need the return id 'cause we already know it
 			.map(|_: Option<ImageId>| ())
-			.map_err(|e| (page_num, DisplayErrSource::Transmission(e)))
+			.map_err(DisplayErrSource::Transmission)
 		};
 
 		log::debug!("this_err is {this_err:#?}");
 
-		if let Err((id, e)) = this_err {
+		if let Err(e) = this_err {
 			match err.as_mut() {
-				Ok(()) => err = Err((SmallVec::from([id].as_slice()), e)),
-				Err((v, _)) => v.push(id)
+				Ok(()) => err = Err((SmallVec::from([page_num].as_slice()), e)),
+				Err((v, _)) => v.push(page_num)
 			}
 		}
 	}
 
-	err.map_err(|(failed_pages, source)| DisplayErr {
-		failed_pages,
-		user_facing_err: "Couldn't transfer image to the terminal",
-		source
-	})
+	let z_idxes_to_remove = *last_z_index;
+	*last_z_index = new_z_index;
+
+	match err {
+		Err((failed_pages, source)) => Err(DisplayErr {
+			failed_pages,
+			user_facing_err: "Couldn't transfer image to the terminal",
+			source
+		}),
+		Ok(()) => run_action(
+			Action::Delete(DeleteConfig {
+				effect: ClearOrDelete::Clear,
+				which: WhichToDelete::PlacementsWithZIndex(z_idxes_to_remove)
+			}),
+			ev_stream
+		)
+		.await
+		.map_err(|e| DisplayErr::empty("Couldn't clear previously-sent images", e))
+		.map(|_| ())
+	}
 }

src/main.rs

@@ -5,7 +5,7 @@ use core::{
 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},
@@ -116,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
@@ -137,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.
@@ -390,6 +404,8 @@ async fn enter_redraw_loop(
 	mut main_area: tdf::tui::RenderLayout,
 	font_size: FontSize
 ) -> Result<(), Box<dyn Error>> {
+	let mut kitty_z_idx = i32::MIN;
+
 	loop {
 		let mut needs_redraw = true;
 		let next_ev = ev_stream.next().fuse();
@@ -462,7 +478,8 @@ async fn enter_redraw_loop(
 				to_display = tui.render(f, &main_area, font_size);
 			})?;
 
-			let maybe_err = display_kitty_images(to_display, &mut ev_stream).await;
+			let maybe_err =
+				display_kitty_images(to_display, &mut ev_stream, &mut kitty_z_idx).await;
 
 			if let Err(DisplayErr {
 				failed_pages,
@@ -562,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");
@@ -628,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/tui.rs

@@ -72,7 +72,7 @@ struct PageConstraints {
 	r_to_l: bool
 }
 
-#[derive(Default, Debug)]
+#[derive(Default, Debug, Clone, Copy)]
 struct Zoom {
 	// just how much 'zoom' you have. 0 means it fills the screen (instead of fits), such
 	// that one axis is fully on-screen
@@ -86,7 +86,7 @@ struct Zoom {
 }
 impl Zoom {
 	/// Returns the zoom factor, where 1 is the default and means fill-screen
-	fn factor(&self) -> f32 {
+	fn factor(self) -> f32 {
 		// TODO: Make these configurable once we have a good way to set options after startup
 		const ZOOM_RATE: f32 = 1.1;
 		const ZOOM_RATE_GRANULAR: f32 = 1.05;
@@ -262,7 +262,7 @@ impl Tui {
 			let img_page_w_ratio = img_section_w / initial_page_w;
 			let img_page_h_ratio = img_section_h / initial_page_h;
 
-			let shrink_move_page = |dim: &mut u16, pos: &mut u16, axis_zoom_factor: f32| {
+			fn shrink_move_page(dim: &mut u16, pos: &mut u16, axis_zoom_factor: f32) {
 				let old_dim = *dim;
 				// The axis zoom factor tells us what portion of the axis
 				// we need to show.
@@ -272,26 +272,56 @@ impl Tui {
 					.checked_sub(*dim)
 					.expect("zooming out should shrink the image")
 					/ 2;
-			};
-
-			// TODO: Detect max zoom-out in zoom levels
-			if img_page_w_ratio < img_page_h_ratio {
-				// vertical scroll / tall image. zooming out means decreasing the width of the page area
-				shrink_move_page(
-					&mut img_area.width,
-					&mut img_area.x,
-					// disallow zooming out past fit-screen
-					zoom_factor.max(1.0 / img_page_h_ratio)
-				);
-			} else {
-				// horizontal scroll / wide image. zooming out means decreasing the width of the page area
-				shrink_move_page(
-					&mut img_area.height,
-					&mut img_area.y,
-					// disallow zooming out past fit-screen
-					zoom_factor.max(1.0 / img_page_w_ratio)
-				);
 			}
+
+			fn shrink_move_two_pass(
+				zoom: &mut Zoom,
+				dim: &mut u16,
+				pos: &mut u16,
+				zoom_factor: f32,
+				axis_zoom_factor: f32
+			) {
+				// To detect if we're already at fit-screen, we perform a first
+				// pass on `img_area` that emulates the last call to
+				// `render_zoomed` by subtracting from the `zoom`'s level. This
+				// holds because the `img_area` that gets passed is always the
+				// same.
+				let mut first_pass_dim = *dim;
+				let mut first_pass_pos = *pos;
+				let mut first_pass_zoom = *zoom;
+
+				if first_pass_zoom.level.is_negative() {
+					first_pass_zoom.step_in();
+				}
+				let first_pass_zoom_factor = first_pass_zoom.factor();
+				shrink_move_page(
+					&mut first_pass_dim,
+					&mut first_pass_pos,
+					first_pass_zoom_factor.max(1.0 / axis_zoom_factor)
+				);
+
+				log::debug!("first_pass_dim: {first_pass_dim}, first_pass_pos: {first_pass_pos}");
+				// vertical scroll / tall image. zooming out means decreasing
+				// the width of the page area
+				// use `max` to disallow zooming out past fit-screen
+				shrink_move_page(dim, pos, zoom_factor.max(1.0 / axis_zoom_factor));
+
+				log::debug!("new dim: {dim}, new pos: {pos}");
+				// The moment the image area is left unmodified, we've hit
+				// fit-screen and the zoom level ought be normalized.
+				if first_pass_dim == *dim && first_pass_pos == *pos {
+					zoom.step_in();
+				}
+			}
+
+			let (dim, pos, axis_zoom_factor) = if img_page_w_ratio < img_page_h_ratio {
+				(&mut img_area.width, &mut img_area.x, img_page_h_ratio)
+			} else {
+				// horizontal scroll / wide image. zooming out means decreasing
+				// the height of the page area
+				(&mut img_area.height, &mut img_area.y, img_page_w_ratio)
+			};
+			shrink_move_two_pass(zoom, dim, pos, zoom_factor, axis_zoom_factor);
 		}
 		log::debug!("after adjustment, page area is {img_area:#?}");
 
@@ -709,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),