Release version 0.5.0

.gitignore

@@ -1,4 +1,2 @@
 /target
 debug.log
-/.envrc
-/.direnv/

CHANGELOG.md

@@ -1,7 +1,5 @@
 # Unreleased
 
-- 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)!)
-
 # v0.5.0
 
 - Switched simd base64 crate for one that works on stable (from `vb64` to `base64_simd`)

Cargo.toml

@@ -23,10 +23,10 @@ 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 = { git = "https://github.com/itsjunetime/ratatui.git" }
 # 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 = "a276a87cb8e2976442c6cc59db831db81551da89", default-features = false }
+ratatui-image = { git = "https://github.com/itsjunetime/ratatui-image.git", branch = "vb64_on_personal", default-features = false }
 # ratatui-image = { path = "./ratatui-image", default-features = false }
 crossterm = { version = "0.29.0", features = ["event-stream"] }
 # crossterm = { path = "../crossterm", features = ["event-stream"] }
@@ -34,17 +34,16 @@ image = { version = "0.25.1", features = ["pnm", "rayon", "png"], default-featur
 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"] }
+flume = { version = "0.11.0", default-features = false, features = ["async"] }
 xflags = "0.4.0-pre.2"
 mimalloc = "0.1.43"
-nix = { version = "0.31.0", features = ["signal"] }
+nix = { version = "0.30.0", features = ["signal"] }
 mupdf = { git = "https://github.com/messense/mupdf-rs.git", rev = "2e0fae910fac8048c7008211fc4d3b9f5d227a07", default-features = false, features = ["svg", "system-fonts", "img"] }
 rayon = { version = "1", default-features = false }
 # kittage = { path = "../kittage/", features = ["crossterm-tokio", "image-crate", "log"] }
 kittage = { version = "0.1.1", features = ["crossterm-tokio", "image-crate", "log"] }
 memmap2 = "0"
 csscolorparser = { version = "0.8.0", default-features = false }
-debounce = "0.2.2"
 
 # logging
 log = "0.4.27"
@@ -52,6 +51,7 @@ flexi_logger = "0.31"
 
 # for tracing with tokio-console
 console-subscriber = { version = "0.5.0", optional = true }
+debounce = "0.2.2"
 
 [profile.production]
 inherits = "release"
@@ -64,7 +64,7 @@ epub = ["mupdf/epub"]
 cbz = ["mupdf/cbz"]
 
 [dev-dependencies]
-criterion = { version = "0.8.0", features = ["async_tokio"] }
+criterion = { version = "0.7.0", features = ["async_tokio"] }
 cpuprofiler = "0.0.4"
 
 [[bench]]

benches/utils.rs

@@ -65,6 +65,7 @@ pub fn start_rendering_loop(
 	Sender<RenderNotif>
 ) {
 	let pathbuf = path.as_ref().canonicalize().unwrap();
+	let str_path = pathbuf.into_os_string().to_string_lossy().to_string();
 
 	let (to_render_tx, from_main_rx) = unbounded();
 	let (to_main_tx, from_render_rx) = unbounded();
@@ -90,7 +91,7 @@ pub fn start_rendering_loop(
 	let cell_width_px = size.width / size.columns;
 	std::thread::spawn(move || {
 		start_rendering(
-			&pathbuf,
+			&str_path,
 			to_main_tx,
 			from_main_rx,
 			cell_height_px,
@@ -116,7 +117,6 @@ pub fn start_converting_loop(
 	let (to_converter_tx, from_main_rx) = unbounded();
 	let (to_main_tx, from_converter_rx) = unbounded();
 
-	#[expect(deprecated)]
 	let mut picker = Picker::from_fontsize(FONT_SIZE);
 	picker.set_protocol_type(proto);
 

shell.nix

@@ -5,7 +5,10 @@ pkgs.mkShell {
   nativeBuildInputs = [ pkgs.pkg-config ];
 
   buildInputs = [
+    pkgs.cargo
+    pkgs.rustc
     pkgs.rustPlatform.bindgenHook
     pkgs.cairo
+    pkgs.rust-analyzer
   ];
 }

src/main.rs

@@ -39,7 +39,7 @@ use tdf::{
 	PrerenderLimit,
 	converter::{ConvertedPage, ConverterMsg, run_conversion_loop},
 	kitty::{KittyDisplay, display_kitty_images, do_shms_work, run_action},
-	renderer::{self, MUPDF_BLACK, MUPDF_WHITE, RenderError, RenderInfo, RenderNotif},
+	renderer::{self, RenderError, RenderInfo, RenderNotif},
 	tui::{BottomMessage, InputAction, MessageSetting, Tui}
 };
 
@@ -128,37 +128,21 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		.canonicalize()
 		.map_err(|e| WrappedErr(format!("Cannot canonicalize provided file: {e}").into()))?;
 
-	let black = flags
+	let black =
-		.black_color
+		parse_color_to_i32(flags.black_color.as_deref().unwrap_or("000000")).map_err(|e| {
-		.as_deref()
+			WrappedErr(
-		.map(|color| {
+				format!("Couldn't parse black color: {e} - is it formatted like a CSS 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);
 
-	let white = flags
+	let white =
-		.white_color
+		parse_color_to_i32(flags.white_color.as_deref().unwrap_or("FFFFFF")).map_err(|e| {
-		.as_deref()
+			WrappedErr(
-		.map(|color| {
+				format!("Couldn't parse white color: {e} - is it formatted like a CSS 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);
 
 	// 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.
@@ -209,6 +193,10 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		)
 		.map_err(|e| WrappedErr(format!("Can't watch the provided file: {e}").into()))?;
 
+	// TODO: Handle non-utf8 file names? Maybe by constructing a CString and passing that in to the
+	// mupdf stuff instead of a rust string?
+	let file_path = path.clone().into_os_string().to_string_lossy().to_string();
+
 	let mut window_size = window_size().map_err(|e| {
 		WrappedErr(format!("Can't get your current terminal window size: {e}").into())
 	})?;
@@ -246,13 +234,8 @@ async fn inner_main() -> Result<(), WrappedErr> {
 				window_size.width != 0
 				&& window_size.height != 0
 				&& window_size.columns != 0
-				&& window_size.rows != 0 =>
+				&& window_size.rows != 0
-			{
+					=> Ok(Picker::from_fontsize((cell_width_px, cell_height_px))),
-				// 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)))
-			},
 			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()
 			)),
@@ -267,7 +250,6 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		.and_then(NonZeroUsize::new)
 		.map_or(PrerenderLimit::All, PrerenderLimit::Limited);
 
-	let file_path = path.clone();
 	std::thread::spawn(move || {
 		renderer::start_rendering(
 			&file_path,

src/renderer.rs

@@ -1,4 +1,4 @@
-use std::{collections::VecDeque, num::NonZeroUsize, path::Path, thread::sleep, time::Duration};
+use std::{collections::VecDeque, num::NonZeroUsize, thread::sleep, time::Duration};
 
 use flume::{Receiver, SendError, Sender, TryRecvError};
 use mupdf::{
@@ -57,8 +57,8 @@ struct PrevRender {
 	num_search_found: Option<usize>
 }
 
-pub const MUPDF_BLACK: i32 = 0;
+const MUPDF_BLACK: i32 = 0;
-pub const MUPDF_WHITE: i32 = i32::from_be_bytes([0, 0xff, 0xff, 0xff]);
+const MUPDF_WHITE: i32 = i32::from_be_bytes([0, 0xff, 0xff, 0xff]);
 
 #[inline]
 pub fn fill_default<T: Default>(vec: &mut Vec<T>, size: usize) {
@@ -80,7 +80,7 @@ pub fn fill_default<T: Default>(vec: &mut Vec<T>, size: usize) {
 // probably be more performant if accessed by-value instead of through a reference. Probably.
 #[expect(clippy::needless_pass_by_value, clippy::too_many_arguments)]
 pub fn start_rendering(
-	path: &Path,
+	path: &str,
 	sender: Sender<Result<RenderInfo, RenderError>>,
 	receiver: Receiver<RenderNotif>,
 	col_h: u16,
@@ -152,8 +152,8 @@ pub fn start_rendering(
 
 		sender.send(Ok(RenderInfo::NumPages(n_pages.get())))?;
 
-		// We're using this vec to indicate which page numbers have already been rendered, to
+		// We're using this vec of bools to indicate which page numbers have already been rendered,
-		// support people jumping to specific pages and having quick rendering results. We
+		// to support people jumping to specific pages and having quick rendering results. We
 		// `split_at_mut` at 0 initially (which bascially makes `right == rendered && left == []`),
 		// doing basically nothing, but if we get a notification that something has been jumped to,
 		// then we can split at that page and render at both sides of it
@@ -277,7 +277,7 @@ pub fn start_rendering(
 				// we only want to continue if one of the following is met:
 				// 1. It failed to render last time (we want to retry)
 				// 2. The `contained_term` is set to Unknown, meaning that we need to at least
-				//    check if it contains the current term to see if it needs a re-render
+				//	  check if it contains the current term to see if it needs a re-render
 				if rendered.successful && rendered.num_search_found.is_some() {
 					continue;
 				}
@@ -570,15 +570,4 @@ impl Iterator for PopOnNext<'_> {
 	fn next(&mut self) -> Option<Self::Item> {
 		self.inner.pop_front()
 	}
-
-	fn size_hint(&self) -> (usize, Option<usize>) {
-		let l = self.len();
-		(l, Some(l))
-	}
-}
-
-impl ExactSizeIterator for PopOnNext<'_> {
-	fn len(&self) -> usize {
-		self.inner.len()
-	}
 }

src/tui.rs

@@ -102,70 +102,6 @@ impl Zoom {
 			ZOOM_RATE_GRANULAR.powi(self.level.into())
 		}
 	}
-
-	fn step_in(&mut self) {
-		self.level = self.level.saturating_add(1);
-	}
-	fn step_out(&mut self) {
-		self.level = self.level.saturating_sub(1);
-	}
-
-	// TODO: Make this configurable, maybe allow fractional steps?
-	// With fractional steps, it might also be a good idea to have these
-	// have the same ratio as the font aspect ratio.
-	const PAN_STEP_X: i16 = 2;
-	const PAN_STEP_Y: i16 = 1;
-
-	fn pan(&mut self, direction: Direction) {
-		let (target, sign) = match direction {
-			Direction::Up => (&mut self.cell_pan_from_top, -1),
-			Direction::Down => (&mut self.cell_pan_from_top, 1),
-			Direction::Left => (&mut self.cell_pan_from_left, -1),
-			Direction::Right => (&mut self.cell_pan_from_left, 1)
-		};
-		let step = if direction.is_vertical() {
-			Self::PAN_STEP_Y
-		} else {
-			Self::PAN_STEP_X
-		};
-		*target = target.saturating_add_signed(sign * step);
-	}
-	fn pan_bottom(&mut self) {
-		self.cell_pan_from_top = 0;
-	}
-	fn pan_top(&mut self) {
-		self.cell_pan_from_top = u16::MAX;
-	}
-	fn pan_left(&mut self) {
-		self.cell_pan_from_left = 0;
-	}
-	fn pan_right(&mut self) {
-		self.cell_pan_from_left = u16::MAX;
-	}
-}
-#[derive(Clone, Copy, Debug)]
-enum Direction {
-	Up,
-	Down,
-	Left,
-	Right
-}
-impl Direction {
-	/// Flips the directions for vertical and horizonal panning.
-	fn flip_mouse_xy(self) -> Self {
-		match self {
-			Self::Up => Self::Left,
-			Self::Left => Self::Up,
-			Self::Down => Self::Right,
-			Self::Right => Self::Down
-		}
-	}
-	fn is_vertical(self) -> bool {
-		match self {
-			Self::Up | Self::Down => true,
-			Self::Left | Self::Right => false
-		}
-	}
 }
 
 // This seems like a kinda weird struct because it holds two optionals but any representation
@@ -352,6 +288,7 @@ impl Tui {
 		}])
 	}
 
+	// TODO: Make a way to fill the width of the screen with one page and scroll down to view it
 	#[must_use]
 	pub fn render<'s>(
 		&'s mut self,
@@ -700,8 +637,6 @@ impl Tui {
 			InputAction::JumpingToPage(new_page)
 		}
 
-		let can_zoom = self.is_kitty && self.zoom.is_some();
-
 		match ev {
 			Event::Key(key) => {
 				match key.code {
@@ -718,7 +653,7 @@ impl Tui {
 							self.bottom_msg
 						{
 							if c == 'g' && self.is_kitty {
-								self.update_zoom(Zoom::pan_bottom);
+								self.update_zoom(|z| z.cell_pan_from_top = 0);
 								self.set_msg(MessageSetting::Pop);
 								return Some(InputAction::Redraw);
 							}
@@ -827,15 +762,24 @@ impl Tui {
 								self.last_render.rect = Rect::default();
 								Some(InputAction::SwitchRenderZoom(f_or_f))
 							}
-							'o' if can_zoom => self.update_zoom(Zoom::step_in),
+							'o' if self.is_kitty =>
-							'O' if can_zoom => self.update_zoom(Zoom::step_out),
+								self.update_zoom(|z| z.level = z.level.saturating_add(1)),
-							'L' if can_zoom => self.update_zoom(|z| z.pan(Direction::Right)),
+							'O' if self.is_kitty =>
-							'H' if can_zoom => self.update_zoom(|z| z.pan(Direction::Left)),
+								self.update_zoom(|z| z.level = z.level.saturating_sub(1)),
-							'J' if can_zoom => self.update_zoom(|z| z.pan(Direction::Down)),
+							'L' if self.is_kitty => self.update_zoom(|z| {
-							'K' if can_zoom => self.update_zoom(|z| z.pan(Direction::Up)),
+								z.cell_pan_from_left = z.cell_pan_from_left.saturating_add(1);
-							'G' if can_zoom => self.update_zoom(Zoom::pan_top),
+							}),
-							'0' if can_zoom => self.update_zoom(Zoom::pan_left),
+							'H' if self.is_kitty => self.update_zoom(|z| {
-							'$' if can_zoom => self.update_zoom(Zoom::pan_right),
+								z.cell_pan_from_left = z.cell_pan_from_left.saturating_sub(1);
+							}),
+							'J' if self.is_kitty => self.update_zoom(|z| {
+								z.cell_pan_from_top = z.cell_pan_from_top.saturating_add(1);
+							}),
+							'K' if self.is_kitty => self.update_zoom(|z| {
+								z.cell_pan_from_top = z.cell_pan_from_top.saturating_sub(1);
+							}),
+							'G' if self.is_kitty =>
+								self.update_zoom(|z| z.cell_pan_from_top = u16::MAX),
 							_ => None
 						}
 					}
@@ -922,36 +866,29 @@ impl Tui {
 				}
 			}
 			Event::Mouse(mouse) => {
-				let mut handle_scroll = |mut direction: Direction| {
+				if mouse.modifiers.contains(KeyModifiers::CONTROL)
-					if can_zoom {
+					&& self.is_kitty
-						if mouse.modifiers.contains(KeyModifiers::CONTROL) {
+					&& self.zoom.is_some()
-							match direction {
+				{
-								Direction::Up => self.update_zoom(Zoom::step_in),
+					match mouse.kind {
-								Direction::Down => self.update_zoom(Zoom::step_out),
+						MouseEventKind::ScrollUp =>
-								_ => None
+							self.update_zoom(|z| z.level = z.level.saturating_add(1).min(0)),
-							}
+						MouseEventKind::ScrollDown =>
-						} else {
+							self.update_zoom(|z| z.level = z.level.saturating_sub(1)),
-							if mouse.modifiers.contains(KeyModifiers::SHIFT) {
+						_ => None
-								direction = direction.flip_mouse_xy();
+					}
-							}
+				} else {
-							self.update_zoom(|z| z.pan(direction))
+					match mouse.kind {
-						}
+						MouseEventKind::ScrollRight =>
-					} else {
+							self.change_page(PageChange::Next, ChangeAmount::Single),
-						let (change, amount) = match direction {
+						MouseEventKind::ScrollDown =>
-							Direction::Right => (PageChange::Next, ChangeAmount::Single),
+							self.change_page(PageChange::Next, ChangeAmount::WholeScreen),
-							Direction::Down => (PageChange::Next, ChangeAmount::WholeScreen),
+						MouseEventKind::ScrollLeft =>
-							Direction::Left => (PageChange::Prev, ChangeAmount::Single),
+							self.change_page(PageChange::Prev, ChangeAmount::Single),
-							Direction::Up => (PageChange::Prev, ChangeAmount::WholeScreen)
+						MouseEventKind::ScrollUp =>
-						};
+							self.change_page(PageChange::Prev, ChangeAmount::WholeScreen),
-						self.change_page(change, amount)
+						_ => None
 					}
-				};
-				match mouse.kind {
-					MouseEventKind::ScrollRight => handle_scroll(Direction::Right),
-					MouseEventKind::ScrollDown => handle_scroll(Direction::Down),
-					MouseEventKind::ScrollLeft => handle_scroll(Direction::Left),
-					MouseEventKind::ScrollUp => handle_scroll(Direction::Up),
-					_ => None
 				}
 			}
 			Event::Resize(_, _) => Some(InputAction::Redraw),
@@ -1105,8 +1042,6 @@ gg/G (when on fill-screen):
     Scroll to top/bottom of page
 H, J, K, L (when zoomed in):
     Pan direction around page
-0/$ (when on fill-screen):
-    Scroll to left/right side of page
 ";
 
 pub enum InputAction {