switch benches over to other runtime

* ci: format

* ci: run on tag push, manual dispatch

* ci: release a tip on each push to `main` and tag release on tag pushes

* ci: run on more platforms

* ci: don't fail fast

* ci: enable windows

* Update .github/workflows/rust.yml

Co-authored-by: June <61218022+itsjunetime@users.noreply.github.com>

* Update .github/workflows/rust.yml

Co-authored-by: June <61218022+itsjunetime@users.noreply.github.com>

* Update .github/workflows/rust.yml

Co-authored-by: June <61218022+itsjunetime@users.noreply.github.com>

* chore: update custom `ratatui-image` rev

* Update .github/workflows/rust.yml

Co-authored-by: June <61218022+itsjunetime@users.noreply.github.com>

* Update .github/workflows/rust.yml

Co-authored-by: June <61218022+itsjunetime@users.noreply.github.com>

* chore(deps): update kittage

* Update kittage for maybe more windows fixes

* Update kittage again for more windows fixes

* Update kittage again.....

* Maybe actually compile windows correctly now?

* update kittage

* oopsie forgot abt lock file

* windows and kittage again ...

* maybe fix the file path conversion stuff?

* kittage once again...........

---------

Co-authored-by: June <61218022+itsjunetime@users.noreply.github.com>
Co-authored-by: itsjunetime <junewelker@gmail.com>

.github/workflows/rust.yml

@@ -2,41 +2,144 @@ name: Rust
 
 on:
   push:
-    branches: [ "main" ]
+    branches: ["main"]
+    tags: ["v*.*.*"]
   pull_request:
-    branches: [ "main" ]
+    branches: ["main"]
+  workflow_dispatch:
+  workflow_call:
 
 env:
   CARGO_TERM_COLOR: always
+  tip_release_path: RELEASE.md
 
 jobs:
-  build:
+  test-build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { os: "macos-latest", target: "aarch64-apple-darwin" }
+          - { os: "ubuntu-latest", target: "x86_64-unknown-linux-gnu" }
+          - {
+              os: "windows-latest",
+              target: "x86_64-pc-windows-msvc",
+              ext: ".exe",
+            }
+          - { os: "ubuntu-24.04-arm", target: "aarch64-unknown-linux-gnu" }
 
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
 
     steps:
-    - name: Setup sccache
+      - uses: actions/checkout@v6
-      if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
+
-      uses: mozilla-actions/sccache-action@v0.0.8
+      - name: Setup sccache
-    - name: Configure sccache
+        if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
-      if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
+        uses: mozilla-actions/sccache-action@v0.0.8
-      run: |
+      - name: Configure sccache
-        echo "SCCACHE_GHA_ENABLED=true" >> $GITHUB_ENV
+        if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
-        echo "RUSTC_WRAPPER=sccache" >> $GITHUB_ENV
+        run: |
-    - name: Install build dependencies
+          echo "SCCACHE_GHA_ENABLED=true" >> "$GITHUB_ENV"
-      run: |
+          echo "RUSTC_WRAPPER=sccache" >> "$GITHUB_ENV"
-        sudo apt-get update
+
-        sudo apt-get install -y libfontconfig1-dev libgoogle-perftools-dev google-perftools
+      - name: Setup rust cache action
-    - uses: actions/checkout@v4
+        uses: swatinem/rust-cache@v2
-    - name: Install clippy and fmt
+        with:
-      run: rustup component add clippy rustfmt
+          cache-on-failure: true
-    - name: Clippy
+
-      run: cargo clippy --locked -- -D warnings
+      - name: install build dependencies on ubuntu and cache
-    - name: Tests
+        if: contains(matrix.os, 'ubuntu')
-      run: cargo test --locked
+        uses: awalsh128/cache-apt-pkgs-action@latest
-    - name: Check fmt
+        with:
-      run: cargo fmt -- --check
+          packages: libfontconfig1-dev libgoogle-perftools-dev google-perftools
-    - name: Run benchmarks as tests
+          version: latest # could be anything
-      run: cargo test --locked --benches -- adobe_example
+
-    - name: Build
+      - name: Install clippy and fmt
-      run: cargo build --locked
+        run: rustup component add clippy rustfmt
+      - name: Clippy
+        run: cargo clippy --locked -- -D warnings
+      - name: Tests
+        run: cargo test --locked
+      - name: Check fmt
+        run: cargo fmt -- --check
+      - name: Run benchmarks as tests
+        run: cargo test --locked --benches -- adobe_example
+
+      - name: Set build mode
+        shell: bash
+        run: if [ "${{github.ref_type}}" == "tag" ] || [ ${{ github.event_name == 'push' && github.ref_name == 'main' }} ]; then echo "BMODE=production">>"$GITHUB_ENV"; fi
+
+      - name: Build in ${{env.BMODE || 'debug'}} mode
+        run: cargo build --verbose --locked --profile ${{env.BMODE || 'dev'}}
+
+      - name: Prepare artifact
+        shell: bash
+        run: |
+          mkdir -p dist
+          cp "target/${{env.BMODE || 'debug'}}/tdf${{ matrix.ext }}" dist/tdf-${{ matrix.target }}${{ matrix.ext }}
+          tree dist || ls -la dist
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v5
+        with:
+          name: tdf-${{ matrix.target }}
+          path: dist/tdf*
+
+  tag-release:
+    name: Release on tag push
+    runs-on: ubuntu-slim
+    if: github.ref_type == 'tag'
+    needs: test-build
+    steps:
+      - uses: actions/download-artifact@v6
+        with:
+          pattern: "**/tdf-*"
+          path: release-artifacts
+          merge-multiple: true
+
+      - name: What's up?
+        run: tree release-artifacts # beautiful!
+
+      - name: Create a GitHub release
+        uses: softprops/action-gh-release@v2
+        with:
+          draft: true
+          generate_release_notes: true
+          files: release-artifacts/*
+          prerelease: ${{ contains(github.ref, 'alpha') || contains(github.ref, 'beta') || contains(github.ref, 'rc') }}
+
+  tip-release:
+    name: Release tip on push to main
+    runs-on: ubuntu-slim
+    if: github.event_name == 'push' && github.ref_name == 'main'
+    needs: test-build
+
+    steps:
+      - uses: actions/checkout@v6
+      - name: Download prebuilt artifacts
+        uses: actions/download-artifact@v7
+        with:
+          path: release-artifacts
+          merge-multiple: true
+
+      - name: Generate release notes
+        run: |
+          tree release-artifacts/
+          echo "From commit: $(git rev-parse --short HEAD)" > ${{ env.tip_release_path }}
+          echo "Generated on: $(date -u +"%Y-%m-%d %H:%M") UTC" >> ${{ env.tip_release_path }}
+          cat ${{ env.tip_release_path }}
+
+      - name: Update the tip tag
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git tag --force tip && git push --force origin tag tip
+
+      - name: Update the draft tip release
+        uses: softprops/action-gh-release@v2
+        with:
+          prerelease: true
+          files: release-artifacts/*
+          tag_name: tip
+          name: Tip Build
+          body_path: ${{ env.tip_release_path }}

.gitignore

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

CHANGELOG.md

@@ -1,5 +1,9 @@
 # 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)!)
+- (Internal) decreased runtime footprint of tokio runtime
+
 # 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" }
+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", branch = "vb64_on_personal", default-features = false }
+ratatui-image = { git = "https://github.com/itsjunetime/ratatui-image.git", rev = "a276a87cb8e2976442c6cc59db831db81551da89", 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,16 +34,17 @@ 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.11.0", default-features = false, features = ["async"] }
+flume = { version = "0.12.0", default-features = false, features = ["async"] }
 xflags = "0.4.0-pre.2"
 mimalloc = "0.1.43"
-nix = { version = "0.30.0", features = ["signal"] }
+nix = { version = "0.31.0", features = ["signal"] }
-mupdf = { git = "https://github.com/messense/mupdf-rs.git", rev = "2e0fae910fac8048c7008211fc4d3b9f5d227a07", default-features = false, features = ["svg", "system-fonts", "img"] }
+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.1.1", 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"
 
 # logging
 log = "0.4.27"
@@ -51,7 +52,6 @@ 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.7.0", features = ["async_tokio"] }
+criterion = { version = "0.8.0", features = ["async_tokio"] }
 cpuprofiler = "0.0.4"
 
 [[bench]]

benches/rendering.rs

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

benches/utils.rs

@@ -65,7 +65,6 @@ 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();
@@ -91,7 +90,7 @@ pub fn start_rendering_loop(
 	let cell_width_px = size.width / size.columns;
 	std::thread::spawn(move || {
 		start_rendering(
-			&str_path,
+			&pathbuf,
 			to_main_tx,
 			from_main_rx,
 			cell_height_px,
@@ -117,6 +116,7 @@ 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,10 +5,7 @@ pkgs.mkShell {
   nativeBuildInputs = [ pkgs.pkg-config ];
 
   buildInputs = [
-    pkgs.cargo
-    pkgs.rustc
     pkgs.rustPlatform.bindgenHook
     pkgs.cairo
-    pkgs.rust-analyzer
   ];
 }

src/converter.rs

@@ -144,10 +144,14 @@ pub async fn run_conversion_loop(
 					.as_nanos() % 1_000_000;
 
 				let mut img = if shms_work {
-					kittage::image::Image::shm_from(dyn_img, &format!("/tdf_{pid}_{rn}_{page_num}"))
+					let shm_name = format!("/tdf_{pid}_{rn}_{page_num}");
-						.map_err(|e| {
+
-							RenderError::Converting(format!("Couldn't write to shm: {e:?}"))
+					#[cfg(unix)]
-						})?
+					let shm_name = &*shm_name;
+
+					kittage::image::Image::shm_from(dyn_img, shm_name).map_err(|e| {
+						RenderError::Converting(format!("Couldn't create shm: {e:?}"))
+					})?
 				} else {
 					kittage::image::Image::from(dyn_img)
 				};

src/kitty.rs

@@ -78,7 +78,12 @@ pub async fn run_action<'es>(
 pub async fn do_shms_work(ev_stream: &mut EventStream) -> bool {
 	let img = DynamicImage::new_rgb8(1, 1);
 	let pid = std::process::id();
-	let Ok(mut k_img) = kittage::image::Image::shm_from(img, &format!("tdf_test_{pid}")) else {
+	let shm_name = format!("tdf_test_{pid}");
+
+	#[cfg(unix)]
+	let shm_name = &*shm_name;
+
+	let Ok(mut k_img) = kittage::image::Image::shm_from(img, shm_name) else {
 		return false;
 	};
 

src/lib.rs

@@ -42,7 +42,7 @@ pub fn scale_img_for_area(
 
 	// and get the ratio that this page would have to be scaled by to fit perfectly within the
 	// area provided to us.
-	// we do this first by comparing the aspec ratio of the page with the aspect ratio of the
+	// we do this first by comparing the aspect ratio of the page with the aspect ratio of the
 	// area to fit it within. If the aspect ratio of the page is larger, then we need to scale
 	// the width of the page to fill perfectly within the height of the area. Otherwise, we
 	// scale the height to fit perfectly. The dimension that _is not_ scaled to fit perfectly

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, RenderError, RenderInfo, RenderNotif},
+	renderer::{self, MUPDF_BLACK, MUPDF_WHITE, RenderError, RenderInfo, RenderNotif},
 	tui::{BottomMessage, InputAction, MessageSetting, Tui}
 };
 
@@ -70,11 +70,18 @@ fn reset_term() {
 	);
 }
 
-#[tokio::main]
+fn main() -> Result<(), WrappedErr> {
-async fn main() -> Result<(), WrappedErr> {
+	let rt = tokio::runtime::Builder::new_multi_thread()
-	let result = inner_main().await;
+		.worker_threads(3)
-	reset_term();
+		.enable_time()
-	result
+		.build()
+		.unwrap();
+
+	rt.block_on(async move {
+		let result = inner_main().await;
+		reset_term();
+		result
+	})
 }
 
 async fn inner_main() -> Result<(), WrappedErr> {
@@ -128,21 +135,37 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		.canonicalize()
 		.map_err(|e| WrappedErr(format!("Cannot canonicalize provided file: {e}").into()))?;
 
-	let black =
+	let black = flags
-		parse_color_to_i32(flags.black_color.as_deref().unwrap_or("000000")).map_err(|e| {
+		.black_color
-			WrappedErr(
+		.as_deref()
-				format!("Couldn't parse black color: {e} - is it formatted like a CSS color?")
+		.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);
 
-	let white =
+	let white = flags
-		parse_color_to_i32(flags.white_color.as_deref().unwrap_or("FFFFFF")).map_err(|e| {
+		.white_color
-			WrappedErr(
+		.as_deref()
-				format!("Couldn't parse white color: {e} - is it formatted like a CSS color?")
+		.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);
 
 	// 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.
@@ -193,10 +216,6 @@ 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())
 	})?;
@@ -234,8 +253,13 @@ 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()
 			)),
@@ -250,6 +274,7 @@ 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,
@@ -383,6 +408,7 @@ async fn enter_redraw_loop(
 						},
 						InputAction::Search(term) => to_renderer.send(RenderNotif::Search(term))?,
 						InputAction::Invert => to_renderer.send(RenderNotif::Invert)?,
+						InputAction::Rotate => to_renderer.send(RenderNotif::Rotate)?,
 						InputAction::Fullscreen => fullscreen = !fullscreen,
 						InputAction::SwitchRenderZoom(f_or_f) => {
 							to_renderer.send(RenderNotif::SwitchFitOrFill(f_or_f)).unwrap();

src/renderer.rs

@@ -1,4 +1,4 @@
-use std::{collections::VecDeque, num::NonZeroUsize, thread::sleep, time::Duration};
+use std::{collections::VecDeque, num::NonZeroUsize, path::Path, thread::sleep, time::Duration};
 
 use flume::{Receiver, SendError, Sender, TryRecvError};
 use mupdf::{
@@ -20,7 +20,8 @@ pub enum RenderNotif {
 	Search(String),
 	SwitchFitOrFill(FitOrFill),
 	Reload,
-	Invert
+	Invert,
+	Rotate
 }
 
 #[derive(Debug)]
@@ -37,6 +38,14 @@ pub enum RenderInfo {
 	Reloaded
 }
 
+#[derive(Debug, Copy, Clone)]
+pub enum RotateDirection {
+	Deg0,
+	Deg90,
+	Deg180,
+	Deg270
+}
+
 #[derive(Clone)]
 pub struct PageInfo {
 	pub img_data: ImageData,
@@ -57,8 +66,8 @@ struct PrevRender {
 	num_search_found: Option<usize>
 }
 
-const MUPDF_BLACK: i32 = 0;
+pub const MUPDF_BLACK: i32 = 0;
-const MUPDF_WHITE: i32 = i32::from_be_bytes([0, 0xff, 0xff, 0xff]);
+pub 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 +89,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: &str,
+	path: &Path,
 	sender: Sender<Result<RenderInfo, RenderError>>,
 	receiver: Receiver<RenderNotif>,
 	col_h: u16,
@@ -98,13 +107,21 @@ pub fn start_rendering(
 
 	let mut stored_doc = None;
 	let mut invert = false;
+	let mut rotate = RotateDirection::Deg0;
 	let mut preserved_area = None;
 	let mut fit_or_fill = FitOrFill::Fit;
 
 	let mut need_rerender = VecDeque::new();
 
+	#[cfg(windows)]
+	let path = path.to_string_lossy();
+
 	'reload: loop {
-		let doc = match Document::open(path) {
+		// Need to do this weird borrow thing so that we convert `Cow<'_, str>` -> `&str` on windows
+		// and keep unix a `&Path` -> `&Path` 'cause there are different requirements within mupdf
+		// about file paths per-platform
+		#[cfg_attr(unix, expect(clippy::borrow_deref_ref))]
+		let doc = match Document::open(&*path) {
 			Err(e) => {
 				// if there's an error, tell the main loop
 				sender.send(Err(RenderError::Doc(e)))?;
@@ -152,8 +169,8 @@ pub fn start_rendering(
 
 		sender.send(Ok(RenderInfo::NumPages(n_pages.get())))?;
 
-		// We're using this vec of bools to indicate which page numbers have already been rendered,
+		// We're using this vec to indicate which page numbers have already been rendered, to
-		// to support people jumping to specific pages and having quick rendering results. We
+		// 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
@@ -238,6 +255,18 @@ pub fn start_rendering(
 							}
 							continue 'render_pages;
 						}
+						RenderNotif::Rotate => {
+							rotate = match rotate {
+								RotateDirection::Deg0 => RotateDirection::Deg90,
+								RotateDirection::Deg90 => RotateDirection::Deg180,
+								RotateDirection::Deg180 => RotateDirection::Deg270,
+								RotateDirection::Deg270 => RotateDirection::Deg0
+							};
+							for page in &mut rendered {
+								page.successful = false;
+							}
+							continue 'render_pages;
+						}
 					}
 				}};
 			}
@@ -277,7 +306,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;
 				}
@@ -301,6 +330,7 @@ pub fn start_rendering(
 					black,
 					white,
 					fit_or_fill,
+					rotate,
 					(area_w, area_h)
 				) {
 					// If that fn returned Some, that means it needed to be re-rendered for some
@@ -455,6 +485,7 @@ fn render_single_page_to_ctx(
 	black: i32,
 	white: i32,
 	fit_or_fill: FitOrFill,
+	rotate: RotateDirection,
 	(area_w, area_h): (f32, f32)
 ) -> Result<RenderedContext, mupdf::error::Error> {
 	let result_rects = match prev_render.num_search_found {
@@ -465,7 +496,12 @@ fn render_single_page_to_ctx(
 
 	// then, get the size of the page
 	let bounds = page.bounds()?;
-	let page_dim = (bounds.x1 - bounds.x0, bounds.y1 - bounds.y0);
+	let page_dim = match rotate {
+		RotateDirection::Deg0 | RotateDirection::Deg180 =>
+			(bounds.x1 - bounds.x0, bounds.y1 - bounds.y0),
+		RotateDirection::Deg90 | RotateDirection::Deg270 =>
+			(bounds.y1 - bounds.y0, bounds.x1 - bounds.x0),
+	};
 
 	let scaled = scale_img_for_area(page_dim, (area_w, area_h), fit_or_fill);
 	let ScaledResult {
@@ -482,7 +518,13 @@ fn render_single_page_to_ctx(
 	}
 
 	let colorspace = Colorspace::device_rgb();
-	let matrix = Matrix::new_scale(scale_factor, scale_factor);
+	let mut matrix = Matrix::new_scale(scale_factor, scale_factor);
+	match rotate {
+		RotateDirection::Deg0 => matrix.rotate(0.0),
+		RotateDirection::Deg90 => matrix.rotate(90.0),
+		RotateDirection::Deg180 => matrix.rotate(180.0),
+		RotateDirection::Deg270 => matrix.rotate(270.0)
+	};
 
 	let mut pixmap = page.to_pixmap(&matrix, &colorspace, false, false)?;
 	if invert {
@@ -494,6 +536,7 @@ fn render_single_page_to_ctx(
 	let (x_res, y_res) = pixmap.resolution();
 	let new_x = (x_res as f32 * scale_factor) as i32;
 	let new_y = (y_res as f32 * scale_factor) as i32;
+
 	pixmap.set_resolution(new_x, new_y);
 
 	let result_rects = result_rects
@@ -570,4 +613,15 @@ 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

@@ -9,10 +9,6 @@ use crossterm::{
 	}
 };
 use kittage::display::DisplayLocation;
-use nix::{
-	sys::signal::{Signal::SIGSTOP, kill},
-	unistd::Pid
-};
 use ratatui::{
 	Frame,
 	layout::{Constraint, Flex, Layout, Position, Rect},
@@ -102,6 +98,70 @@ 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
@@ -288,7 +348,6 @@ 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,
@@ -637,6 +696,8 @@ impl Tui {
 			InputAction::JumpingToPage(new_page)
 		}
 
+		let can_zoom = self.is_kitty && self.zoom.is_some();
+
 		match ev {
 			Event::Key(key) => {
 				match key.code {
@@ -653,7 +714,7 @@ impl Tui {
 							self.bottom_msg
 						{
 							if c == 'g' && self.is_kitty {
-								self.update_zoom(|z| z.cell_pan_from_top = 0);
+								self.update_zoom(Zoom::pan_bottom);
 								self.set_msg(MessageSetting::Pop);
 								return Some(InputAction::Redraw);
 							}
@@ -736,10 +797,17 @@ impl Tui {
 								.unwrap();
 								disable_raw_mode().unwrap();
 
-								// This process will hang after the SIGSTOP call until we get
+								#[cfg(unix)]
-								// foregrounded again by something else, at which point we need to
+								{
-								// re-setup everything so that it all gets drawn again.
+									// This process will hang after the SIGSTOP call until we get
-								kill(Pid::this(), SIGSTOP).unwrap();
+									// foregrounded again by something else, at which point we need to
+									// re-setup everything so that it all gets drawn again.
+									nix::sys::signal::kill(
+										nix::unistd::Pid::this(),
+										nix::sys::signal::Signal::SIGSTOP
+									)
+									.unwrap();
+								}
 
 								enable_raw_mode().unwrap();
 								execute!(
@@ -762,24 +830,16 @@ impl Tui {
 								self.last_render.rect = Rect::default();
 								Some(InputAction::SwitchRenderZoom(f_or_f))
 							}
-							'o' if self.is_kitty =>
+							'o' if can_zoom => self.update_zoom(Zoom::step_in),
-								self.update_zoom(|z| z.level = z.level.saturating_add(1)),
+							'O' if can_zoom => self.update_zoom(Zoom::step_out),
-							'O' if self.is_kitty =>
+							'L' if can_zoom => self.update_zoom(|z| z.pan(Direction::Right)),
-								self.update_zoom(|z| z.level = z.level.saturating_sub(1)),
+							'H' if can_zoom => self.update_zoom(|z| z.pan(Direction::Left)),
-							'L' if self.is_kitty => self.update_zoom(|z| {
+							'J' if can_zoom => self.update_zoom(|z| z.pan(Direction::Down)),
-								z.cell_pan_from_left = z.cell_pan_from_left.saturating_add(1);
+							'K' if can_zoom => self.update_zoom(|z| z.pan(Direction::Up)),
-							}),
+							'G' if can_zoom => self.update_zoom(Zoom::pan_top),
-							'H' if self.is_kitty => self.update_zoom(|z| {
+							'0' if can_zoom => self.update_zoom(Zoom::pan_left),
-								z.cell_pan_from_left = z.cell_pan_from_left.saturating_sub(1);
+							'$' if can_zoom => self.update_zoom(Zoom::pan_right),
-							}),
+							'r' => Some(InputAction::Rotate),
-							'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
 						}
 					}
@@ -866,29 +926,36 @@ impl Tui {
 				}
 			}
 			Event::Mouse(mouse) => {
-				if mouse.modifiers.contains(KeyModifiers::CONTROL)
+				let mut handle_scroll = |mut direction: Direction| {
-					&& self.is_kitty
+					if can_zoom {
-					&& self.zoom.is_some()
+						if mouse.modifiers.contains(KeyModifiers::CONTROL) {
-				{
+							match direction {
-					match mouse.kind {
+								Direction::Up => self.update_zoom(Zoom::step_in),
-						MouseEventKind::ScrollUp =>
+								Direction::Down => self.update_zoom(Zoom::step_out),
-							self.update_zoom(|z| z.level = z.level.saturating_add(1).min(0)),
+								_ => None
-						MouseEventKind::ScrollDown =>
+							}
-							self.update_zoom(|z| z.level = z.level.saturating_sub(1)),
+						} else {
-						_ => None
+							if mouse.modifiers.contains(KeyModifiers::SHIFT) {
-					}
+								direction = direction.flip_mouse_xy();
-				} else {
+							}
-					match mouse.kind {
+							self.update_zoom(|z| z.pan(direction))
-						MouseEventKind::ScrollRight =>
+						}
-							self.change_page(PageChange::Next, ChangeAmount::Single),
+					} else {
-						MouseEventKind::ScrollDown =>
+						let (change, amount) = match direction {
-							self.change_page(PageChange::Next, ChangeAmount::WholeScreen),
+							Direction::Right => (PageChange::Next, ChangeAmount::Single),
-						MouseEventKind::ScrollLeft =>
+							Direction::Down => (PageChange::Next, ChangeAmount::WholeScreen),
-							self.change_page(PageChange::Prev, ChangeAmount::Single),
+							Direction::Left => (PageChange::Prev, ChangeAmount::Single),
-						MouseEventKind::ScrollUp =>
+							Direction::Up => (PageChange::Prev, ChangeAmount::WholeScreen)
-							self.change_page(PageChange::Prev, ChangeAmount::WholeScreen),
+						};
-						_ => None
+						self.change_page(change, amount)
 					}
+				};
+				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),
@@ -1042,6 +1109,10 @@ 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
+r:
+		Rotate by 90 degrees
 ";
 
 pub enum InputAction {
@@ -1050,6 +1121,7 @@ pub enum InputAction {
 	Search(String),
 	QuitApp,
 	Invert,
+	Rotate,
 	Fullscreen,
 	SwitchRenderZoom(crate::FitOrFill)
 }