fmt

* wip; start working on making it not flash when transferring new images

* don't delete the images, just clear them

* add changelog entry

* fmt

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)!)
+- 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

@@ -22,14 +22,9 @@ 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 = "a276a87cb8e2976442c6cc59db831db81551da89", 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"] }
@@ -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", branch = "fix_nightly_arm_simd" }
-
 [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: _,
@@ -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

@@ -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

@@ -260,7 +260,7 @@ async fn inner_main() -> Result<(), WrappedErr> {
 				// 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(
 				"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()
@@ -315,7 +315,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(
@@ -390,6 +390,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 +464,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,

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

@@ -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:#?}");
 
@@ -319,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
@@ -337,8 +367,8 @@ 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,
@@ -379,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;
 		}