Remove tip workflow

CHANGELOG.md

@@ -1,9 +1,6 @@
 # Unreleased
 
-- 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)!)
-- Fixed issue with images clearing/flashing after displaying a certain number on kitty
-- (Internal) decreased runtime footprint of tokio runtime
 
 # v0.5.0
 

Cargo.toml

@@ -11,7 +11,7 @@ license = "AGPL-3.0-only"
 keywords = ["pdf", "tui", "cli", "terminal"]
 categories = ["command-line-utilities", "text-processing", "visualization"]
 default-run = "tdf"
-rust-version = "1.95"
+rust-version = "1.86"
 
 [[bin]]
 name = "tdf"
@@ -41,11 +41,10 @@ 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 }
 # kittage = { path = "../kittage/", features = ["crossterm-tokio", "image-crate", "log"] }
-kittage = { version = "0.4.0", features = ["crossterm-tokio", "image-crate", "log"] }
+kittage = { version = "0.3.4", features = ["crossterm-tokio", "image-crate", "log"] }
 memmap2 = "0"
 csscolorparser = { version = "0.8.0", default-features = false }
 debounce = "0.2.2"
-smallvec = "1"
 
 # logging
 log = "0.4.27"
@@ -54,9 +53,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/rendering.rs

@@ -34,12 +34,7 @@ fn for_all_combos(
 	name: &'static str,
 	mut f: impl FnMut(&Runtime, BenchmarkId, &'static str, ProtocolType)
 ) {
-	let rt = tokio::runtime::Builder::new_multi_thread()
+	let rt = tokio::runtime::Runtime::new().unwrap();
-		.worker_threads(3)
-		.enable_time()
-		.build()
-		.unwrap();
-
 	for proto in PROTOS {
 		for file in FILES {
 			f(

src/converter.rs

@@ -1,13 +1,12 @@
 use std::{
-	io::Cursor,
+	num::NonZeroUsize,
-	num::{NonZeroU32, NonZeroUsize},
 	time::{SystemTime, UNIX_EPOCH}
 };
 
 use flume::{Receiver, SendError, Sender, TryRecvError};
 use futures_util::stream::StreamExt as _;
-use image::{DynamicImage, codecs::pnm::PnmDecoder};
+use image::DynamicImage;
-use kittage::NumberOrId;
+use kittage::{NumberOrId, action::NONZERO_ONE};
 use ratatui::layout::Rect;
 use ratatui_image::{
 	Resize,
@@ -112,26 +111,22 @@ pub async fn run_conversion_loop(
 			return Ok(None);
 		};
 
-		let decoder = PnmDecoder::new(Cursor::new(&page_info.img_data.pixels)).map_err(|e| {
+		let mut dyn_img = image::load_from_memory_with_format(
-			RenderError::Converting(format!(
+			&page_info.img_data.pixels,
-				"The image data provided from mupdf was not in pnm format ({e}); don't know how to convert"
+			image::ImageFormat::Pnm
-			))
+		)
-		})?;
+		.map_err(|e| RenderError::Converting(format!("Can't load image: {e}")))?;
-
-		// The image we get should always already be `ImageRgb8`, so this `into` shouldn't do any
-		// conversions or anything, but just in case some underlying detail of mupdf or image
-		// changes, we do the `into` instead of just `match + unreachable!()` to avoid panicking
-		let mut dyn_img = DynamicImage::from_decoder(decoder)
-			.map_err(|e| RenderError::Converting(format!("Can't load image: {e}")))?
-			.into_rgb8();
 
+		match dyn_img {
+			DynamicImage::ImageRgb8(ref mut img) =>
 				for quad in &*page_info.result_rects {
-			dyn_img
+					img.par_enumerate_pixels_mut()
-				.par_enumerate_pixels_mut()
 						.filter(|(x, y, _)| {
 							*x > quad.ul_x && *x < quad.lr_x && *y > quad.ul_y && *y < quad.lr_y
 						})
 						.for_each(|(_, _, px)| px.0[2] = px.0[2].saturating_sub(u8::MAX / 2));
+				},
+			_ => unreachable!()
 		}
 
 		let img_area = Rect {
@@ -141,8 +136,6 @@ pub async fn run_conversion_loop(
 			y: 0
 		};
 
-		let dyn_img = DynamicImage::ImageRgb8(dyn_img);
-
 		let txt_img = match picker.protocol_type() {
 			ProtocolType::Kitty => {
 				let rn = SystemTime::now()
@@ -164,7 +157,7 @@ pub async fn run_conversion_loop(
 				};
 
 				// if ur pdf has 4 billion pages then you deserve to suffer
-				img.num_or_id = NumberOrId::Id(NonZeroU32::MIN.saturating_add(page_num as u32));
+				img.num_or_id = NumberOrId::Id(NONZERO_ONE.saturating_add(page_num as u32));
 
 				ConvertedImage::Kitty {
 					img: MaybeTransferred::NotYet(img),

src/kitty.rs

@@ -1,4 +1,3 @@
-use core::fmt::Display;
 use std::{io::Write, num::NonZeroU32};
 
 use crossterm::{
@@ -18,7 +17,6 @@ use kittage::{
 	medium::Medium
 };
 use ratatui::layout::Position;
-use smallvec::SmallVec;
 
 use crate::converter::MaybeTransferred;
 
@@ -65,7 +63,7 @@ impl<W: Write> Write for DbgWriter<W> {
 pub async fn run_action<'es>(
 	action: Action<'_, '_>,
 	ev_stream: &'es mut EventStream
-) -> Result<Option<ImageId>, TransmitError<<&'es mut EventStream as AsyncInputReader>::Error>> {
+) -> Result<ImageId, TransmitError<<&'es mut EventStream as AsyncInputReader>::Error>> {
 	let writer = DbgWriter {
 		w: std::io::stdout().lock(),
 		#[cfg(debug_assertions)]
@@ -101,51 +99,21 @@ pub async fn do_shms_work(ev_stream: &mut EventStream) -> bool {
 	res.is_ok()
 }
 
-type ESTransErr<'es> = TransmitError<<&'es mut EventStream as AsyncInputReader>::Error>;
-
-pub struct DisplayErr<'es> {
-	pub failed_pages: SmallVec<[usize; 2]>,
-	pub user_facing_err: &'static str,
-	pub source: DisplayErrSource<'es>
-}
-
-impl<'es> DisplayErr<'es> {
-	fn empty(user_facing_err: &'static str, source: ESTransErr<'es>) -> Self {
-		Self {
-			failed_pages: SmallVec::new(),
-			user_facing_err,
-			source: DisplayErrSource::Transmission(source)
-		}
-	}
-}
-
-#[derive(Debug)]
-pub enum DisplayErrSource<'es> {
-	KittageReturnedNoId,
-	Transmission(ESTransErr<'es>)
-}
-
-impl Display for DisplayErrSource<'_> {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		match self {
-			Self::KittageReturnedNoId => write!(
-				f,
-				"Kittage returned no ID when we asked it to display an image. This is a bug in kittage, please report it."
-			),
-			Self::Transmission(t) => write!(f, "Error with talking to the terminal: {t}")
-		}
-	}
-}
-
 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<
-) -> Result<(), DisplayErr<'es>> {
+	(),
+	(
+		Vec<usize>,
+		&'static str,
+		TransmitError<<&'es mut EventStream as AsyncInputReader>::Error>
+	)
+> {
 	let images = match display {
 		KittyDisplay::NoChange => return Ok(()),
-		KittyDisplay::ClearImages =>
+		KittyDisplay::DisplayImages(_) | KittyDisplay::ClearImages => {
-			return run_action(
+			run_action(
 				Action::Delete(DeleteConfig {
 					effect: ClearOrDelete::Clear,
 					which: WhichToDelete::All
@@ -153,23 +121,24 @@ pub async fn display_kitty_images<'es>(
 				ev_stream
 			)
 			.await
-			.map_err(|e| DisplayErr::empty("Couldn't clear previous images", e))
+			.map_err(|e| (vec![], "Couldn't clear previous images", e))?;
-			.map(|_: Option<ImageId>| ()),
+
-		KittyDisplay::DisplayImages(imgs) => imgs
+			let KittyDisplay::DisplayImages(images) = display else {
+				return Ok(());
 			};
 
-	let new_z_index = last_z_index.wrapping_add_unsigned(1);
+			images
+		}
+	};
 
-	let mut err = Ok::<(), (SmallVec<[usize; 2]>, DisplayErrSource<'es>)>(());
+	let mut err = None;
 	for KittyReadyToDisplay {
 		img,
 		page_num,
 		pos,
-		mut display_loc
+		display_loc
 	} in images
 	{
-		display_loc.z_index = new_z_index;
-
 		let config = DisplayConfig {
 			location: display_loc,
 			cursor_movement: CursorMovementPolicy::DontMove,
@@ -199,7 +168,7 @@ pub async fn display_kitty_images<'es>(
 				};
 				std::mem::swap(image, &mut fake_image);
 
-				run_action(
+				let res = run_action(
 					Action::TransmitAndDisplay {
 						image: fake_image,
 						config,
@@ -207,13 +176,15 @@ pub async fn display_kitty_images<'es>(
 					},
 					ev_stream
 				)
-				.await
+				.await;
-				.map_err(DisplayErrSource::Transmission)
+
-				.and_then(|img_id| {
+				match res {
-					img_id
+					Ok(img_id) => {
-						.map(|id| *img = MaybeTransferred::Transferred(id))
+						*img = MaybeTransferred::Transferred(img_id);
-						.ok_or(DisplayErrSource::KittageReturnedNoId)
+						Ok(())
-				})
+					}
+					Err(e) => Err((page_num, e))
+				}
 			}
 			MaybeTransferred::Transferred(image_id) => run_action(
 				Action::Display {
@@ -224,39 +195,20 @@ pub async fn display_kitty_images<'es>(
 				ev_stream
 			)
 			.await
-			// don't need the return id 'cause we already know it
+			.map(|_| ())
-			.map(|_: Option<ImageId>| ())
+			.map_err(|e| (page_num, e))
-			.map_err(DisplayErrSource::Transmission)
 		};
 
 		log::debug!("this_err is {this_err:#?}");
 
-		if let Err(e) = this_err {
+		if let Err((id, e)) = this_err {
-			match err.as_mut() {
+			let e = err.get_or_insert_with(|| (vec![], e));
-				Ok(()) => err = Err((SmallVec::from([page_num].as_slice()), e)),
+			e.0.push(id);
-				Err((v, _)) => v.push(page_num)
 		}
 	}
-	}
-
-	let z_idxes_to_remove = *last_z_index;
-	*last_z_index = new_z_index;
 
 	match err {
-		Err((failed_pages, source)) => Err(DisplayErr {
+		Some((replace, e)) => Err((replace, "Couldn't transfer image to the terminal", e)),
-			failed_pages,
+		None => Ok(())
-			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

@@ -38,9 +38,7 @@ use ratatui_image::{
 use tdf::{
 	PrerenderLimit,
 	converter::{ConvertedPage, ConverterMsg, run_conversion_loop},
-	kitty::{
+	kitty::{KittyDisplay, 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}
 };
@@ -72,18 +70,11 @@ fn reset_term() {
 	);
 }
 
-fn main() -> Result<(), WrappedErr> {
+#[tokio::main]
-	let rt = tokio::runtime::Builder::new_multi_thread()
+async fn main() -> Result<(), WrappedErr> {
-		.worker_threads(3)
-		.enable_time()
-		.build()
-		.unwrap();
-
-	rt.block_on(async move {
 	let result = inner_main().await;
 	reset_term();
 	result
-	})
 }
 
 async fn inner_main() -> Result<(), WrappedErr> {
@@ -390,8 +381,6 @@ 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();
@@ -464,16 +453,10 @@ async fn enter_redraw_loop(
 				to_display = tui.render(f, &main_area, font_size);
 			})?;
 
-			let maybe_err =
+			let maybe_err = display_kitty_images(to_display, &mut ev_stream).await;
-				display_kitty_images(to_display, &mut ev_stream, &mut kitty_z_idx).await;
 
-			if let Err(DisplayErr {
+			if let Err((to_replace, err_desc, enum_err)) = maybe_err {
-				failed_pages,
+				match enum_err {
-				user_facing_err,
-				source
-			}) = maybe_err
-			{
-				match source {
 					// This is the error that kitty & ghostty provide us when they delete an
 					// image due to memory constraints, so if we get it, we just fix it by
 					// re-rendering so it don't display it to the user
@@ -481,15 +464,13 @@ async fn enter_redraw_loop(
 					// [TODO] maybe when we detect that an image was deleted, we probe the
 					// terminal for the pages around it to see if they were deleted too and if
 					// they were, we re-render them? idk
-					DisplayErrSource::Transmission(TransmitError::Terminal(
+					TransmitError::Terminal(TerminalError::NoEntity(_)) => (),
-						TerminalError::NoEntity(_)
-					)) => (),
 					_ => tui.set_msg(MessageSetting::Some(BottomMessage::Error(format!(
-						"{user_facing_err}: {source}"
+						"{err_desc}: {enum_err}"
 					))))
 				}
 
-				for page_num in failed_pages {
+				for page_num in to_replace {
 					tui.page_failed_display(page_num);
 					// So that they get re-rendered and sent over again
 					to_renderer.send(RenderNotif::PageNeedsReRender(page_num))?;

src/tui.rs

@@ -72,7 +72,7 @@ struct PageConstraints {
 	r_to_l: bool
 }
 
-#[derive(Default, Debug, Clone, Copy)]
+#[derive(Default, Debug)]
 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;
 
-			fn shrink_move_page(dim: &mut u16, pos: &mut u16, axis_zoom_factor: f32) {
+			let 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,56 +272,26 @@ impl Tui {
 					.checked_sub(*dim)
 					.expect("zooming out should shrink the image")
 					/ 2;
-			}
-
-			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);
+
+			// 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)
+				);
+			}
 		}
 		log::debug!("after adjustment, page area is {img_area:#?}");
 
@@ -731,28 +701,31 @@ impl Tui {
 		match ev {
 			Event::Key(key) => {
 				match key.code {
-					KeyCode::Char(c)
+					KeyCode::Char(c) => {
+						// TODO: refactor back to `if let` arm guards when those are stabilized
 						if let BottomMessage::Input(InputCommand::Search(ref mut term)) =
-							self.bottom_msg =>
+							self.bottom_msg
 						{
 							term.push(c);
-						InputAction::Redraw.into()
+							return Some(InputAction::Redraw);
 						}
-					KeyCode::Char(c)
+
 						if let BottomMessage::Input(InputCommand::GoToPage(ref mut page)) =
-							self.bottom_msg && matches!(c, 'g' if self.is_kitty) =>
+							self.bottom_msg
-						c.to_digit(10).map(|input_num| {
+						{
+							if c == 'g' && self.is_kitty {
+								self.update_zoom(Zoom::pan_bottom);
+								self.set_msg(MessageSetting::Pop);
+								return Some(InputAction::Redraw);
+							}
+
+							return 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.set_msg(MessageSetting::Pop);
-						self.update_zoom(Zoom::pan_bottom)
 						}
-					KeyCode::Char(c) => match c {
+
+						match c {
 							'l' => self.change_page(PageChange::Next, ChangeAmount::Single),
 							'j' => self.change_page(PageChange::Next, ChangeAmount::WholeScreen),
 							'h' => self.change_page(PageChange::Prev, ChangeAmount::Single),
@@ -776,10 +749,10 @@ impl Tui {
 								Some(InputAction::Redraw)
 							}
 							'f' => Some(InputAction::Fullscreen),
+							'n' if self.page < self.rendered.len() - 1 => {
 								// TODO: If we can't find one, then maybe like block until we've verified
 								// all the pages have been checked?
-						'n' if self.page < self.rendered.len() - 1 => self.rendered
+								self.rendered[(self.page + 1)..]
-							[(self.page + 1)..]
 									.iter()
 									.enumerate()
 									.find_map(|(idx, p)| {
@@ -788,8 +761,13 @@ impl Tui {
 											.then_some(self.page + 1 + idx)
 									})
 									.map(|next_page| {
-								jump_to_page(&mut self.page, &mut self.last_render.rect, next_page)
+										jump_to_page(
-							}),
+											&mut self.page,
+											&mut self.last_render.rect,
+											next_page
+										)
+									})
+							}
 							'N' if self.page > 0 => self.rendered[..(self.page)]
 								.iter()
 								.rev()
@@ -800,7 +778,11 @@ impl Tui {
 										.then_some(self.page - (idx + 1))
 								})
 								.map(|prev_page| {
-								jump_to_page(&mut self.page, &mut self.last_render.rect, prev_page)
+									jump_to_page(
+										&mut self.page,
+										&mut self.last_render.rect,
+										prev_page
+									)
 								}),
 							'z' if key.modifiers.contains(KeyModifiers::CONTROL) => {
 								// [todo] better error handling here?
@@ -859,13 +841,16 @@ impl Tui {
 							'$' if can_zoom => self.update_zoom(Zoom::pan_right),
 							'r' => Some(InputAction::Rotate),
 							_ => None
-					},
+						}
-					KeyCode::Backspace
+					}
+					KeyCode::Backspace => {
 						if let BottomMessage::Input(InputCommand::Search(ref mut term)) =
-							self.bottom_msg =>
+							self.bottom_msg
 						{
 							term.pop();
-						InputAction::Redraw.into()
+							return Some(InputAction::Redraw);
+						}
+						None
 					}
 					KeyCode::Right => self.change_page(PageChange::Next, ChangeAmount::Single),
 					KeyCode::Down | KeyCode::PageDown =>