Clean merge: Update deps, implement gg/G keybinds, fix issues

Author: Shem Torga

.gitignore

@@ -1,2 +1,3 @@
 /target
 debug.log
+.DS_Store

CHANGELOG.md

@@ -1,6 +1,10 @@
 # Unreleased
 
 - Switched simd base64 crate for one that works on stable (from `vb64` to `base64_simd`)
+- Allow boolean arguments to function as flags, without a `true` or `false` argument following the flag itself
+- Fix cropping issues when zooming out too much while using kitty protocol
+- Added `gg` and `G` keybindings for scrolling to the top and bottom of a page, respectively, when filling the width of the screen with kitty
+- Updated help page to only show kitty keybindings when you're actually using kitty
 
 # v0.4.3
 

Cargo.toml

@@ -39,18 +39,19 @@ xflags = "0.4.0-pre.2"
 mimalloc = "0.1.43"
 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"] }
+webbrowser = "0.6"
 rayon = { version = "*", default-features = false }
 # kittage = { path = "../kittage/", features = ["crossterm-tokio", "image-crate", "log"] }
 kittage = { git = "https://github.com/itsjunetime/kittage.git", features = ["crossterm-tokio", "image-crate", "log"] }
 memmap2 = "*"
+csscolorparser = { version = "0.8.0", default-features = false }
 
 # logging
 log = "0.4.27"
 flexi_logger = "0.31"
 
 # for tracing with tokio-console
-console-subscriber = { version = "0.4.0", optional = true }
-csscolorparser = { version = "0.7.0" }
+console-subscriber = { version = "0.5.0", optional = true }
 
 [profile.production]
 inherits = "release"
@@ -92,7 +93,7 @@ checked_conversions = "warn"
 copy_iterator = "warn"
 default_trait_access = "warn"
 doc_link_with_quotes = "warn"
-empty_enum = "warn"
+empty_enums = "warn"
 explicit_into_iter_loop = "warn"
 explicit_iter_loop = "warn"
 filter_map_next = "warn"

src/main.rs

@@ -35,7 +35,7 @@ use tdf::{
 	PrerenderLimit,
 	converter::{ConvertedPage, ConverterMsg, run_conversion_loop},
 	kitty::{KittyDisplay, display_kitty_images, do_shms_work, run_action},
-	renderer::{self, RenderError, RenderInfo, RenderNotif},
+	renderer::{self, LinkTarget, RenderError, RenderInfo, RenderNotif},
 	tui::{BottomMessage, InputAction, MessageSetting, Tui}
 };
 
@@ -83,11 +83,11 @@ async fn inner_main() -> Result<(), WrappedErr> {
 	let flags = xflags::parse_or_exit! {
 		/// Display the pdf with the pages starting at the right hand size and moving left and
 		/// adjust input keys to match
-		optional -r,--r-to-l r_to_l: bool
+		optional -r,--r-to-l
 		/// The maximum number of pages to display together, horizontally, at a time
 		optional -m,--max-wide max_wide: NonZeroUsize
 		/// Fullscreen the pdf (hide document name, page count, etc)
-		optional -f,--fullscreen fullscreen: bool
+		optional -f,--fullscreen
 		/// The number of pages to prerender surrounding the currently-shown page; 0 means no
 		/// limit. By default, there is no limit.
 		optional -p,--prerender prerender: usize
@@ -267,12 +267,7 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		|| "Unknown file".into(),
 		|n| n.to_string_lossy().to_string()
 	);
-	let tui = Tui::new(
-		file_name,
-		flags.max_wide,
-		flags.r_to_l.unwrap_or_default(),
-		is_kitty
-	);
+	let tui = Tui::new(file_name, flags.max_wide, flags.r_to_l, is_kitty);
 
 	let backend = CrosstermBackend::new(std::io::stdout());
 	let mut term = Terminal::new(backend).map_err(|e| {
@@ -300,7 +295,7 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		})?;
 	}
 
-	let fullscreen = flags.fullscreen.unwrap_or_default();
+	let fullscreen = flags.fullscreen;
 	let main_area = Tui::main_layout(&term.get_frame(), fullscreen);
 	to_renderer
 		.send(RenderNotif::Area(main_area.page_area))
@@ -376,6 +371,41 @@ async fn enter_redraw_loop(
 					None => needs_redraw = false,
 					Some(action) => match action {
 						InputAction::Redraw => (),
+						InputAction::Click { col, row } => {
+							if let Some((page_num, mupdf_x, mupdf_y)) = tui.map_click_to_page(col, row, &main_area, font_size) {
+								let (resp_tx, resp_rx) = flume::bounded(1);
+								to_renderer.send(RenderNotif::QueryLinkAt {
+									page: page_num,
+									mupdf_x_px: mupdf_x,
+									mupdf_y_px: mupdf_y,
+									resp: resp_tx
+								})?;
+								// await the renderer reply; the renderer now returns
+								// Result<Option<LinkTarget>, String> so we can display errors
+								match resp_rx.recv_async().await {
+									Ok(Ok(Some(LinkTarget::Uri(uri)))) => {
+										if let Err(e) = webbrowser::open(&uri) {
+											tui.set_msg(MessageSetting::Some(BottomMessage::Error(
+												format!("Failed to open uri {}: {e}", uri)
+											)));
+										}
+									}
+									Ok(Ok(Some(LinkTarget::GoTo { page_index }))) => {
+										to_renderer.send(RenderNotif::JumpToPage(page_index))?;
+										to_converter.send(ConverterMsg::GoToPage(page_index))?;
+									}
+									Ok(Ok(None)) => {},
+									Ok(Err(err_str)) => {
+										tui.set_msg(MessageSetting::Some(BottomMessage::Error(err_str)));
+									}
+									Err(e) => {
+										tui.set_msg(MessageSetting::Some(BottomMessage::Error(
+											format!("Failed to receive link response from renderer: {e}")
+										)));
+									}
+								}
+							}
+						},
 						InputAction::QuitApp => return Ok(()),
 						InputAction::JumpingToPage(page) => {
 							to_renderer.send(RenderNotif::JumpToPage(page))?;

src/renderer.rs

@@ -16,6 +16,18 @@ const KITTY_MAX_W_OR_H: f32 = 10_000.0;
 pub enum RenderNotif {
 	Area(Rect),
 	JumpToPage(usize),
+	/// Query: which link (if any) is under the provided device pixel coords (relative to the
+	/// top-left of the rendered page image). The renderer replies on the provided Sender with
+	/// Some(LinkTarget) if a link was found, otherwise None.
+	QueryLinkAt {
+		page: usize,
+		mupdf_x_px: f32,
+		mupdf_y_px: f32,
+		// Send back either the found link (Some) or None, or an Err(String) describing an
+		// internal failure. If sending on this channel fails it indicates the receiver has
+		// disconnected (main thread exited) and we should panic.
+		resp: Sender<Result<Option<LinkTarget>, String>>
+	},
 	PageNeedsReRender(usize),
 	Search(String),
 	SwitchFitOrFill(FitOrFill),
@@ -37,6 +49,15 @@ pub enum RenderInfo {
 	Reloaded
 }
 
+/// A link target discovered on a page.
+#[derive(Debug, Clone)]
+pub enum LinkTarget {
+	/// External URI to open in a browser
+	Uri(String),
+	/// Internal document destination: page index (0-based)
+	GoTo { page_index: usize }
+}
+
 #[derive(Clone)]
 pub struct PageInfo {
 	pub img_data: ImageData,
@@ -66,6 +87,46 @@ pub fn fill_default<T: Default>(vec: &mut Vec<T>, size: usize) {
 	vec.resize_with(size, T::default);
 }
 
+/// Query which link (if any) is under the provided mupdf device coordinates for the given
+/// page. Returns Ok(Some(LinkTarget)) if a link is found, Ok(None) if no link, or
+/// Err(mupdf::error::Error) on mupdf failures.
+fn query_link_at(
+	doc: &Document,
+	qpage: usize,
+	mupdf_x_px: f32,
+	mupdf_y_px: f32,
+	area_w: f32,
+	area_h: f32,
+	fit_or_fill: FitOrFill,
+) -> Result<Option<LinkTarget>, mupdf::error::Error> {
+	// load the requested page and compute same scale as used when rendering
+	let page = doc.load_page(qpage as i32)?;
+	let bounds = page.bounds()?;
+	let page_dim = (bounds.x1 - bounds.x0, bounds.y1 - bounds.y0);
+	let scaled = scale_img_for_area(page_dim, (area_w, area_h), fit_or_fill);
+	let scale_factor = scaled.scale_factor;
+
+	let pdf_x = mupdf_x_px / scale_factor;
+	let pdf_y = mupdf_y_px / scale_factor;
+
+	if let Ok(links) = page.links() {
+		for link in links {
+			let lb = link.bounds;
+			if pdf_x >= lb.x0 && pdf_x <= lb.x1 && pdf_y >= lb.y0 && pdf_y <= lb.y1 {
+				// prefer URI if present and non-empty
+				if !link.uri.is_empty() {
+					return Ok(Some(LinkTarget::Uri(link.uri)));
+				}
+				if let Some(dest) = link.dest {
+					return Ok(Some(LinkTarget::GoTo { page_index: dest.loc.page_number as usize }));
+				}
+			}
+		}
+	}
+
+	Ok(None)
+}
+
 // this function has to be sync (non-async) because the mupdf::Document needs to be held during
 // most of it, but that's basically just a wrapper around `*c_void` cause it's just a binding to C
 // code, so it's !Send and thus can't be held across await points. So we can't call any of the
@@ -186,6 +247,18 @@ pub fn start_rendering(
 			macro_rules! handle_notif {
 				($notif:ident) => {{
 					match $notif {
+						RenderNotif::QueryLinkAt { page: qpage, mupdf_x_px, mupdf_y_px, resp } => {
+							match query_link_at(&doc, qpage, mupdf_x_px, mupdf_y_px, area_w, area_h, fit_or_fill) {
+								Ok(t) => resp.send(Ok(t)),
+								Err(e) => {
+									let err_str = format!("Failed to query links: {e}");
+									resp.send(Err(err_str))
+								}
+							}
+							.unwrap_or_else(|e| {
+								panic!("Renderer failed to send link-query response: {e}")
+							});
+						}
 						RenderNotif::Reload => continue 'reload,
 						RenderNotif::Invert => {
 							invert = !invert;