diff --git a/.gitignore b/.gitignore
index 6ce25f6..e899205 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,10 @@
/.appimage-tools/
*.AppImage
*.AppImage.zsync
+/dist/*.AppImage.sha256
+/dist/*.tar.gz
+/dist/*.tar.gz.sha256
+/dist/*.tar.gz.part-*
+/dist/*.tar.gz.parts.sha256
+/dist/*-install.sh
+/.release-credentials
diff --git a/AGENTS.md b/AGENTS.md
index 64ce761..39e7884 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -3,14 +3,14 @@
## Project Overview
Comicviewer is a desktop comic archive viewer for CachyOS and Arch Linux.
-It browses local, SMB, FTP, and SFTP locations and opens image files stored in
-ZIP archives.
+It browses local, SMB, FTP, and SFTP locations and opens ZIP archives,
+standalone images, and videos.
## Technology
- Rust
- GTK4 with GIO/GVfs for desktop and remote filesystem integration
-- SQLite for cached directory metadata, search indexes, and reading history
+- SQLite for cached directory metadata and reading history
- AppImage as the primary distribution format
- Korean-first UI with all user-facing strings kept translatable
@@ -20,20 +20,46 @@ ZIP archives.
- Store credentials as plain text in the application configuration as requested,
but restrict the configuration file permissions to `0600`.
- Cache remote directory metadata and refresh it asynchronously when browsing.
+- Cancel a superseded remote directory request so only the latest request can
+ consume resources, update progress, or replace browser entries.
- Download remote ZIP archives before opening them.
- Limit the persistent ZIP cache with a user-configurable LRU quota. The default
is 10 GB. A quota of 0 disables persistent ZIP caching and uses temporary files.
-- Support JPEG, PNG, WebP, static GIF, BMP, and AVIF images in ZIP archives.
+- Evict the oldest unpinned ZIP cache files before a download needs space, at
+ startup, and after an open archive releases its cache pin. Allow users to clear
+ cached ZIPs without deleting open archives or reading history.
+- Keep temporary remote media in the application cache directory, remove it when
+ its viewer closes, and clean stale temporary downloads on the next startup.
+- Support JPEG, PNG, WebP, GIF, BMP, and AVIF images both standalone and in ZIP
+ archives. Play animated GIF and WebP frames with their delays and loop counts.
+- Support common standalone video formats through GStreamer. In video playback,
+ Left/Right seek by five seconds and Up/Down adjust volume by five percent.
- Sort archive images and browser entries using natural filename ordering.
- Support ascending and descending sorting by name, modification time, and
creation time. Treat unavailable creation times as unknown rather than
inventing values.
-- Search folder and ZIP names recursively below the current location using the
- cached index.
+- Filter the currently displayed browser directory by filename and restore all
+ entries when the search text is cleared.
- Provide 100%, fit-width, fit-height, two-page, and continuous vertical viewing.
- Support both right-to-left and left-to-right two-page layouts, plus controls
- that advance by one page to adjust page pairing.
+ that advance by one page to adjust page pairing. Persist the last selected
+ two-page direction and restore it in newly opened archive viewers.
+- Reuse viewer windows when moving between ZIP, image, and video files. Preserve
+ fullscreen state and keep the registered GTK titlebar widget stable while the
+ displayed header changes.
+- Provide a toggleable file list on the right side of each viewer. Double-click
+ or Enter opens the selected viewable file; its context menu provides favorite
+ and download actions.
+- Filter each viewer's current file list with a temporary search field and
+ restore the complete list when the search text is cleared.
+- Accept one local file or folder dropped onto the main window or a viewer.
+ Browse dropped folders in the main window; for dropped files, browse the
+ parent folder and open the exact naturally sorted item in a new viewer window.
+- Save favorites for local and remote folders and files, and preserve the saved
+ location profile needed to reconnect to remote favorites.
- Save progress per ZIP and save the most recently read ZIP for resume support.
+- Let users update from the About window by downloading the fixed Cafe24 latest
+ bundle and checksum, verifying SHA-256, and reusing the atomic installer.
## Data Locations
@@ -50,11 +76,23 @@ Do not write application state into the source tree.
- Prefer the smallest correct implementation and avoid speculative abstractions.
- Keep network and archive work off the GTK main thread.
- Show cached directory data immediately, then update it in the background.
+- Abort superseded GIO futures and guard asynchronous progress and completion
+ callbacks against stale generations or closed/reused windows.
+- Handle file drops as `COPY` actions through `GdkFileList`. Inspect local paths
+ asynchronously, reject ambiguous/multiple drops, and never reuse the source
+ viewer window for a dropped file.
- Use atomic writes for configuration, database migrations, and completed remote
downloads. Incomplete downloads must use a distinct temporary suffix.
+- Reserve persistent cache capacity before writing a known-size remote ZIP.
+ Cache cleanup must skip active temporary downloads and pinned/open archives.
- Do not extract an entire archive to disk. Decode only requested images and
prefetch a small window around the current page.
-- Validate archive entry sizes and image dimensions before allocation.
+- Validate archive entry sizes, image dimensions, animation frame counts, and
+ cumulative decoded animation size before retaining decoded data.
+- Cancel animation timers when pictures are hidden, viewers are replaced, or
+ windows close. GTK/GDK objects must only be created on the GTK main thread.
+- Avoid strong `Rc` cycles between GTK signal handlers and controllers. Viewer
+ teardown must release temporary files, ZIP cache pins, textures, and timers.
- Never trust archive paths or use them as extraction destinations.
- Preserve errors from GIO, ZIP parsing, and image decoding and present concise,
actionable messages in the UI.
@@ -74,8 +112,13 @@ cargo clippy --all-targets --all-features -- -D warnings
cargo test --all-features
```
-Add focused tests for natural sorting, cache eviction, metadata refresh,
-archive filtering, reading progress, and remote file change detection.
+Add focused tests for natural sorting, oldest-first cache eviction, pin and
+temporary-file protection, metadata refresh, archive filtering, animated image
+decoding, video seek/volume calculations, viewer sibling navigation, reading
+progress, dropped-file sorting/index selection, and remote file change
+detection. For UI or packaging changes, also run a GTK startup smoke test with
+isolated XDG directories; release builds must verify the AppImage and downloaded
+release bundle checksums.
## Git Practices
diff --git a/Cargo.lock b/Cargo.lock
index 6731395..44ba40a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -182,17 +182,19 @@ checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
[[package]]
name = "comicviewer"
-version = "0.1.0"
+version = "0.2.20"
dependencies = [
"anyhow",
"chrono",
"filetime",
+ "flate2",
"gtk4",
"image",
"percent-encoding",
"rusqlite",
"serde",
"sha2",
+ "tar",
"tempfile",
"toml 0.9.12+spec-1.1.0",
"zip",
@@ -1211,6 +1213,17 @@ dependencies = [
"version-compare",
]
+[[package]]
+name = "tar"
+version = "0.4.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f6221d9a6003c78398e3b239969f352578258df48c8eb051caadae0015bc840"
+dependencies = [
+ "filetime",
+ "libc",
+ "xattr",
+]
+
[[package]]
name = "target-lexicon"
version = "0.13.5"
@@ -1475,6 +1488,16 @@ dependencies = [
"memchr",
]
+[[package]]
+name = "xattr"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156"
+dependencies = [
+ "libc",
+ "rustix",
+]
+
[[package]]
name = "zerocopy"
version = "0.8.54"
diff --git a/Cargo.toml b/Cargo.toml
index cc97e95..3b72bf0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "comicviewer"
-version = "0.1.0"
+version = "0.2.20"
edition = "2024"
description = "A comic archive viewer for local and remote locations"
license = "GPL-3.0-or-later"
@@ -8,14 +8,16 @@ license = "GPL-3.0-or-later"
[dependencies]
anyhow = "1.0"
chrono = { version = "0.4", default-features = false, features = ["clock"] }
-gtk = { package = "gtk4", version = "0.10", features = ["v4_10"] }
+gtk = { package = "gtk4", version = "0.10", features = ["v4_12"] }
image = { version = "0.25", default-features = false, features = ["avif-native", "bmp", "gif", "jpeg", "png", "webp"] }
filetime = "0.2"
+flate2 = "1.0"
percent-encoding = "2.3"
rusqlite = { version = "0.37", features = ["bundled"] }
serde = { version = "1.0", features = ["derive"] }
sha2 = "0.10"
tempfile = "3.20"
+tar = "0.4"
toml = "0.9"
zip = { version = "8", default-features = false, features = ["deflate"] }
diff --git a/README.md b/README.md
index cd0cdc1..2fcfc44 100644
--- a/README.md
+++ b/README.md
@@ -1,20 +1,26 @@
# Comicviewer
-Comicviewer is a GTK4 desktop application for browsing and reading comic image
-archives stored locally or on SMB, FTP, and SFTP servers.
+Comicviewer is a GTK4 desktop application for browsing ZIP archives, images,
+and videos stored locally or on SMB, FTP, and SFTP servers.
+
+한국어 문서:
+
+- [설치 및 실행 안내](docs/INSTALL.ko.md)
+- [AppImage Release 배포 안내](docs/RELEASING.ko.md)
The project is currently in early development. It supports saved local, SMB,
FTP, and SFTP locations, complete remote ZIP downloads with an LRU cache,
natural sorting, safe on-demand image decoding and prefetching, single-page and
-two-page viewing, continuous vertical scrolling, reading progress, and
-XDG-compliant configuration.
+two-page viewing, continuous vertical scrolling, standalone image and video
+playback, reading progress, and XDG-compliant configuration.
## Development dependencies
On CachyOS or Arch Linux:
```sh
-sudo pacman -S rust gtk4 sqlite gvfs gvfs-smb
+sudo pacman -S rust gtk4 dav1d sqlite gvfs gvfs-smb gstreamer \
+ gst-plugins-base gst-plugins-good gst-plugins-bad gst-libav
```
Run the application with:
@@ -23,16 +29,17 @@ Run the application with:
cargo run
```
-GVfs provides the FTP and SFTP backends. `gvfs-smb` adds SMB support. These
-services must be installed on the host even when Comicviewer is distributed as
-an AppImage.
+The AppImage uses the host's GTK4 and dav1d libraries. GVfs provides the FTP
+and SFTP backends, while `gvfs-smb` adds SMB support. These packages must be
+installed on the host.
Application files are stored below the standard XDG configuration, data, and
cache directories. No runtime state is written into the source tree.
## AppImage
-The AppImage build uses `linuxdeploy` and `linuxdeploy-plugin-gtk`:
+The AppImage build uses `appimagetool`. The script can extract appimagetool
+from a linuxdeploy AppImage when it is not provided directly:
```sh
PATH="/path/to/appimage-tools:$PATH" \
diff --git a/data/io.github.comicviewer.Comicviewer.desktop b/data/io.github.comicviewer.Comicviewer.desktop
index 7578ae7..ee70b54 100644
--- a/data/io.github.comicviewer.Comicviewer.desktop
+++ b/data/io.github.comicviewer.Comicviewer.desktop
@@ -4,9 +4,9 @@ Name=Comicviewer
Name[ko]=코믹뷰어
Comment=Read comic images stored in ZIP archives
Comment[ko]=ZIP으로 압축된 만화 이미지를 봅니다
-Exec=comicviewer
+Exec=comicviewer %f
Icon=io.github.comicviewer.Comicviewer
Terminal=false
Categories=Graphics;Viewer;
-MimeType=application/zip;application/vnd.comicbook+zip;
+MimeType=application/zip;image/jpeg;image/png;image/webp;image/gif;image/bmp;image/avif;video/mp4;video/x-m4v;video/matroska;video/x-matroska;video/webm;video/quicktime;video/vnd.avi;video/x-msvideo;video/mpeg;video/ogg;inode/directory;
StartupNotify=true
diff --git a/data/io.github.comicviewer.Comicviewer.metainfo.xml b/data/io.github.comicviewer.Comicviewer.metainfo.xml
index 1aca08d..1949cfa 100644
--- a/data/io.github.comicviewer.Comicviewer.metainfo.xml
+++ b/data/io.github.comicviewer.Comicviewer.metainfo.xml
@@ -26,6 +26,31 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/dist/Comicviewer-0.1.0-x86_64.AppImage.sha256 b/dist/Comicviewer-0.1.0-x86_64.AppImage.sha256
new file mode 100644
index 0000000..1b41400
--- /dev/null
+++ b/dist/Comicviewer-0.1.0-x86_64.AppImage.sha256
@@ -0,0 +1 @@
+ae696a3913804a39f304d6b111fc987973e81a3a37aa5d50089e5dfe490ac2f0 Comicviewer-0.1.0-x86_64.AppImage
diff --git a/docs/INSTALL.ko.md b/docs/INSTALL.ko.md
new file mode 100644
index 0000000..4c2b483
--- /dev/null
+++ b/docs/INSTALL.ko.md
@@ -0,0 +1,111 @@
+# Comicviewer 설치 및 실행 안내
+
+Comicviewer는 CachyOS와 Arch Linux에서 사용할 수 있는 만화·미디어 뷰어입니다.
+로컬 및 SMB, FTP, SFTP 위치의 ZIP, 이미지, 동영상 파일을 열 수 있습니다.
+
+## 1. 필수 패키지
+
+통합 번들의 설치 스크립트가 다음 필수 패키지 중 누락된 항목을 자동으로
+설치합니다. 설치 과정에서 `sudo` 암호와 pacman 확인을 요청할 수 있습니다.
+
+```sh
+sudo pacman -S fuse2 gtk4 dav1d gvfs gvfs-smb gstreamer curl \
+ gst-plugins-base gst-plugins-good gst-plugins-bad gst-libav
+```
+
+- `fuse2`: AppImage 마운트 및 실행
+- `gtk4` 4.12 이상, `dav1d`: 화면 표시와 이미지 디코딩
+- `gvfs`: FTP와 SFTP 접근
+- `gvfs-smb`: SMB 공유 접근
+- `gstreamer`, `gst-plugins-*`, `gst-libav`: MP4 등 동영상 재생
+- `curl`: About 창에서 최신 업데이트 다운로드
+
+## 2. 권장 방법: 통합 번들로 설치 또는 업데이트
+
+다음 두 파일을 같은 폴더에 다운로드합니다.
+
+- [Comicviewer-latest-x86_64.tar.gz](https://burningtuna.cafe24.com/www/Downloads/Comicviewer/Comicviewer-latest-x86_64.tar.gz)
+- [Comicviewer-latest-x86_64.tar.gz.sha256](https://burningtuna.cafe24.com/www/Downloads/Comicviewer/Comicviewer-latest-x86_64.tar.gz.sha256)
+
+터미널에서 직접 다운로드할 수도 있습니다.
+
+```sh
+curl -fLO https://burningtuna.cafe24.com/www/Downloads/Comicviewer/Comicviewer-latest-x86_64.tar.gz
+curl -fLO https://burningtuna.cafe24.com/www/Downloads/Comicviewer/Comicviewer-latest-x86_64.tar.gz.sha256
+```
+
+체크섬을 확인하고 압축을 푼 뒤 설치 스크립트를 실행합니다.
+
+```sh
+sha256sum -c Comicviewer-latest-x86_64.tar.gz.sha256
+tar -xzf Comicviewer-latest-x86_64.tar.gz
+cd Comicviewer-latest-x86_64
+./install-or-update.sh
+```
+
+스크립트는 AppImage 체크섬을 검증하고 다음 작업을 수행합니다.
+
+- AppImage를 `~/.local/opt/comicviewer/Comicviewer.AppImage`에 설치
+- `~/.local/bin/comicviewer` 실행 링크 생성
+- 애플리케이션 메뉴용 데스크톱 파일과 아이콘 설치
+- 기존 버전이 있으면 검증된 새 AppImage로 원자적으로 교체
+
+이후 재배포된 새 번들을 다운로드해 같은 명령을 실행하면 업데이트됩니다.
+사용자 설정, 읽기 기록, 원격 ZIP 캐시는 그대로 유지됩니다.
+
+제거하려면 압축을 푼 번들 폴더에서 다음을 실행합니다.
+
+```sh
+./install-or-update.sh --uninstall
+```
+
+이 명령은 프로그램과 함께 저장한 위치 및 인증정보, 읽기 기록, 원격 ZIP 캐시를
+모두 삭제합니다. 삭제한 데이터는 복구할 수 없으므로 필요한 설정은 제거 전에
+별도로 백업합니다.
+
+## 데이터 저장 위치
+
+Comicviewer는 XDG 표준 경로를 사용합니다.
+
+- 설정: `${XDG_CONFIG_HOME:-~/.config}/comicviewer/`
+- 읽기 기록과 데이터: `${XDG_DATA_HOME:-~/.local/share}/comicviewer/`
+- 원격 ZIP 캐시: `${XDG_CACHE_HOME:-~/.cache}/comicviewer/`
+
+저장한 원격 위치의 사용자명과 비밀번호는 설정 파일에 평문으로 기록됩니다.
+설정 파일 권한은 `0600`으로 제한되지만, 설정 파일을 다른 사람에게 전달하거나
+공유하지 않아야 합니다.
+
+## 원격 파일 이용 참고 사항
+
+- SMB 접속에는 호스트 시스템의 `gvfs-smb`가 필요합니다.
+- FTP와 SFTP 접속에는 호스트 시스템의 GVfs 서비스가 필요합니다.
+- 원격 ZIP은 열기 전에 로컬 캐시로 완전히 다운로드됩니다.
+- 기본 영구 ZIP 캐시 한도는 10GB이며 오래된 파일부터 자동으로 삭제됩니다.
+- 메인 창의 `캐시 비우기` 버튼으로 현재 열려 있지 않은 ZIP 캐시를 직접 삭제할 수 있습니다.
+- 캐시 한도는 설정 파일의 `cache_quota_gb`로 변경하며, 0은 영구 캐시를 사용하지 않는 값입니다.
+- 메인 창 검색은 현재 표시 중인 폴더의 파일명을 필터링하며, 입력을 지우면 전체 목록을 복원합니다.
+- 위치 목록의 `최근 열어본 파일`은 성공적으로 연 ZIP·이미지·동영상을 최신순으로 최대 100개 보관합니다.
+- 최근 파일 기록에는 원격 위치 재접속 정보가 함께 저장되며 `최근 기록 비우기`로 전체 기록만 삭제할 수 있습니다.
+
+## 뷰어 조작
+
+- `[`와 `]`: 폴더의 이전/다음 ZIP·이미지·동영상 열기
+- `Home`과 `End`: 폴더의 첫 번째/마지막 파일 열기
+- 동영상에서 `←`와 `→`: 5초 뒤/앞으로 이동
+- 동영상에서 `↑`와 `↓`: 음량을 5%씩 조절
+- 이미지에서 `1`, `2`, `3`, `4`: 폭 맞춤, 높이 맞춤, 2페이지, 100%로 전환 (`3`은 ZIP 뷰어에서 사용)
+- 창보다 크게 표시된 이미지에서 `←`, `→`, `↑`, `↓`: 해당 방향으로 최대 100px 이동
+- `L`: 우측 파일 목록 표시 또는 숨기기
+- 파일 목록 상단 검색: 현재 재생 목록을 임시로 필터링하며, 입력을 지우면 전체 목록 복원
+- About 창의 `업데이트`: Cafe24에서 최신 번들을 내려받아 검증 후 사용자 영역에 설치
+- 이미지에서 `+`/`=`와 `-`: 현재 화면의 이미지를 임시로 10%씩 확대 또는 축소
+- 이미지에서 `Ctrl` + 마우스 휠: 현재 화면의 이미지를 임시로 10%씩 확대 또는 축소
+- 2페이지의 `좌→우`/`우→좌` 방향은 마지막 선택을 저장해 다음 뷰어에서 복원
+- 전체 화면에서 마우스 클릭: 숨겨진 컨트롤을 5초 동안 표시
+- 전체 화면에서 `←`, `→`, `↑`, `↓`: 컨트롤을 즉시 숨기고 해당 키 동작 실행
+- 파일 목록의 더블클릭 또는 선택 후 `Enter`: 해당 파일 열기
+- 파일 목록의 우클릭: 즐겨찾기 추가·제거 또는 다운로드
+- 메인 창이나 뷰어에 로컬 파일 드롭: 부모 폴더를 열고 새 뷰어에서 해당 파일 열기
+- 메인 창이나 뷰어에 로컬 폴더 드롭: 메인 창에서 해당 폴더 열기
+
+애니메이션 GIF와 WebP는 standalone 이미지와 ZIP 내부 이미지에서 재생됩니다.
diff --git a/docs/RELEASING.ko.md b/docs/RELEASING.ko.md
new file mode 100644
index 0000000..b124f8f
--- /dev/null
+++ b/docs/RELEASING.ko.md
@@ -0,0 +1,121 @@
+# AppImage Release 배포 안내
+
+지인에게 배포할 때는 AppImage를 Git 소스 이력에 추가하지 않고 Git 서버의
+Release 첨부 파일로 제공하는 방식을 권장합니다. 버전별 바이너리를 커밋하면
+저장소를 복제할 때 모든 과거 바이너리까지 내려받아 저장소가 빠르게 커집니다.
+
+기존 `v0.1.0` AppImage 커밋은 배포 기록으로 유지하되, 다음 버전부터는 이
+절차를 사용합니다.
+
+태그, 프로젝트 버전, AppImage의 내부 버전은 반드시 같아야 합니다. 사용자가
+받는 통합 번들은 버전과 관계없이 `Comicviewer-latest-x86_64.tar.gz`라는 고정
+이름을 사용합니다.
+
+## 1. 버전 갱신
+
+릴리스 전에 다음 위치의 버전이 일치하는지 확인합니다.
+
+- `Cargo.toml`의 패키지 버전
+- `data/io.github.comicviewer.Comicviewer.metainfo.xml`의 릴리스 버전과 날짜
+- `packaging/build-appimage.sh`의 출력 파일 버전
+
+## 2. 품질 검사
+
+```sh
+cargo fmt --check
+cargo clippy --all-targets --all-features -- -D warnings
+cargo test --all-features
+```
+
+모든 검사를 통과한 소스에서 AppImage를 빌드합니다.
+
+## 3. AppImage 빌드
+
+`appimagetool`을 직접 지정하거나, appimagetool을 포함한
+`linuxdeploy-x86_64.AppImage`를 지정합니다. AppImage는 Arch/CachyOS 호스트의
+GTK4와 dav1d를 사용하며 시스템 라이브러리를 내부에 복사하지 않습니다.
+
+```sh
+PATH="/path/to/appimage-tools:$PATH" \
+LINUXDEPLOY="/path/to/appimage-tools/linuxdeploy-x86_64.AppImage" \
+./packaging/build-appimage.sh
+```
+
+완성된 AppImage는 `dist/`에 생성됩니다. 배포 전에 직접 실행해 기본 화면이
+열리는지 확인합니다.
+
+## 4. 통합 배포 번들 생성
+
+AppImage 빌드가 끝나면 다음 스크립트로 체크섬과 통합 `tar.gz` 번들을 한 번에
+생성합니다.
+
+```sh
+./packaging/build-release-bundle.sh
+```
+
+스크립트는 `Cargo.toml`에서 버전을 읽고 다음 파일을 생성합니다.
+
+- `dist/Comicviewer-0.2.20-x86_64.AppImage.sha256`
+- `dist/Comicviewer-latest-x86_64.tar.gz`
+- `dist/Comicviewer-latest-x86_64.tar.gz.sha256`
+
+통합 번들에는 AppImage, 체크섬, 설치·업데이트 스크립트, 데스크톱 파일, 아이콘,
+한국어 설치 안내문이 포함됩니다. `tar.gz`는 실행 권한과 디렉터리 구조를
+보존하므로 ZIP보다 Linux 배포에 적합합니다.
+
+생성된 번들의 압축 목록과 체크섬을 확인합니다.
+
+```sh
+tar -tzf dist/Comicviewer-latest-x86_64.tar.gz
+cd dist
+sha256sum -c Comicviewer-latest-x86_64.tar.gz.sha256
+```
+
+## 5. 소스 커밋과 태그
+
+버전 변경과 문서를 커밋한 뒤 주석 태그를 생성하고 푸시합니다. AppImage 자체는
+`git add -f`로 추가하지 않습니다.
+
+```sh
+git add Cargo.toml Cargo.lock data packaging README.md docs
+git commit -m "Release v0.2.20"
+git tag -a v0.2.20 -m "Comicviewer v0.2.20"
+git push origin main
+git push origin v0.2.20
+```
+
+이미 원격에 공개한 태그는 이동하거나 덮어쓰지 않습니다. 수정이 필요하면 새
+패치 버전을 만듭니다.
+
+## 6. Cafe24 배포
+
+Git 서버의 바이너리 다운로드는 사용하지 않습니다. FTP로 다음 파일을
+`/www/Downloads/Comicviewer/`에 업로드합니다.
+
+- `Comicviewer-latest-x86_64.tar.gz`
+- `Comicviewer-latest-x86_64.tar.gz.sha256`
+
+업로드 후 다음 HTTPS 주소에서 두 파일을 새 디렉터리로 다시 내려받아 체크섬과
+실제 설치를 확인합니다.
+
+```text
+https://burningtuna.cafe24.com/www/Downloads/Comicviewer/Comicviewer-latest-x86_64.tar.gz
+https://burningtuna.cafe24.com/www/Downloads/Comicviewer/Comicviewer-latest-x86_64.tar.gz.sha256
+```
+
+배포 안내에는 다음 내용을 사용합니다.
+
+```text
+지원 환경: CachyOS / Arch Linux x86_64
+필수 패키지: fuse2, gtk4, dav1d, gvfs, gvfs-smb, gstreamer,
+gst-plugins-base, gst-plugins-good, gst-plugins-bad, gst-libav
+
+설치 또는 업데이트:
+위 HTTPS 주소에서 tar.gz와 tar.gz.sha256을 같은 폴더에 다운로드한 뒤 실행합니다.
+sha256sum -c Comicviewer-latest-x86_64.tar.gz.sha256
+tar -xzf Comicviewer-latest-x86_64.tar.gz
+cd Comicviewer-latest-x86_64
+./install-or-update.sh
+```
+
+사용자에게는 [`INSTALL.ko.md`](INSTALL.ko.md) 문서를 함께 안내합니다.
diff --git a/packaging/build-appimage.sh b/packaging/build-appimage.sh
index b0fafed..087ee51 100755
--- a/packaging/build-appimage.sh
+++ b/packaging/build-appimage.sh
@@ -3,7 +3,10 @@ set -euo pipefail
root_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
linuxdeploy="${LINUXDEPLOY:-linuxdeploy-x86_64.AppImage}"
+appimagetool="${APPIMAGETOOL:-}"
output_dir="${OUTPUT_DIR:-${root_dir}/dist}"
+package_id="$(cargo pkgid --manifest-path "${root_dir}/Cargo.toml")"
+version="${package_id##*@}"
work_dir="$(mktemp -d)"
app_dir="${work_dir}/Comicviewer.AppDir"
@@ -14,34 +17,47 @@ trap cleanup EXIT
cargo build --manifest-path "${root_dir}/Cargo.toml" --release
mkdir -p "${output_dir}"
-mkdir -p "${app_dir}/usr/share/metainfo"
+mkdir -p \
+ "${app_dir}/usr/bin" \
+ "${app_dir}/usr/share/applications" \
+ "${app_dir}/usr/share/icons/hicolor/scalable/apps" \
+ "${app_dir}/usr/share/metainfo"
+install -m 0755 "${root_dir}/target/release/comicviewer" "${app_dir}/usr/bin/comicviewer"
+install -m 0755 "${root_dir}/packaging/AppRun" "${app_dir}/AppRun"
+install -m 0644 \
+ "${root_dir}/data/io.github.comicviewer.Comicviewer.desktop" \
+ "${app_dir}/io.github.comicviewer.Comicviewer.desktop"
+install -m 0644 \
+ "${root_dir}/data/io.github.comicviewer.Comicviewer.desktop" \
+ "${app_dir}/usr/share/applications/io.github.comicviewer.Comicviewer.desktop"
+install -m 0644 \
+ "${root_dir}/data/io.github.comicviewer.Comicviewer.svg" \
+ "${app_dir}/io.github.comicviewer.Comicviewer.svg"
+install -m 0644 \
+ "${root_dir}/data/io.github.comicviewer.Comicviewer.svg" \
+ "${app_dir}/usr/share/icons/hicolor/scalable/apps/io.github.comicviewer.Comicviewer.svg"
install -m 0644 \
"${root_dir}/data/io.github.comicviewer.Comicviewer.metainfo.xml" \
"${app_dir}/usr/share/metainfo/io.github.comicviewer.Comicviewer.appdata.xml"
-output_path="${output_dir}/Comicviewer-0.1.0-x86_64.AppImage"
-export LDAI_OUTPUT="${output_path}"
-export PATH="$(dirname "${linuxdeploy}"):${PATH}"
-export APPIMAGE_EXTRACT_AND_RUN=1
-export NO_STRIP=1
+output_path="${output_dir}/Comicviewer-${version}-x86_64.AppImage"
-# The GTK plugin assumes this optional module directory exists on every distro.
-gtk_plugin="$(command -v linuxdeploy-plugin-gtk.sh || true)"
-if [[ -n "${gtk_plugin}" ]] && [[ ! -d "$(pkg-config --variable=libdir gtk4)/gtk-4.0" ]]; then
- patched_plugin="${work_dir}/linuxdeploy-plugin-gtk.sh"
- cp "${gtk_plugin}" "${patched_plugin}"
- sed -i 's| copy_lib_tree "$gtk4_libdir" "$APPDIR/"| if [ -d "$gtk4_libdir" ]; then copy_lib_tree "$gtk4_libdir" "$APPDIR/"; fi|' "${patched_plugin}"
- chmod +x "${patched_plugin}"
- export PATH="${work_dir}:${PATH}"
+if [[ -z "${appimagetool}" ]]; then
+ linuxdeploy_path="$(command -v "${linuxdeploy}" || true)"
+ if [[ -z "${linuxdeploy_path}" ]]; then
+ printf '%s\n' "APPIMAGETOOL 또는 LINUXDEPLOY를 지정하세요." >&2
+ exit 1
+ fi
+ tool_dir="${work_dir}/appimage-tools"
+ mkdir -p "${tool_dir}"
+ (
+ cd "${tool_dir}"
+ "${linuxdeploy_path}" --appimage-extract >/dev/null
+ )
+ appimagetool="${tool_dir}/squashfs-root/plugins/linuxdeploy-plugin-appimage/usr/bin/appimagetool"
fi
-"${linuxdeploy}" \
- --appdir "${app_dir}" \
- --executable "${root_dir}/target/release/comicviewer" \
- --desktop-file "${root_dir}/data/io.github.comicviewer.Comicviewer.desktop" \
- --icon-file "${root_dir}/data/io.github.comicviewer.Comicviewer.svg" \
- --custom-apprun "${root_dir}/packaging/AppRun" \
- --plugin gtk \
- --output appimage
+env ARCH=x86_64 APPIMAGE_EXTRACT_AND_RUN=1 \
+ "${appimagetool}" "${app_dir}" "${output_path}"
echo "Created ${output_path}"
diff --git a/packaging/build-release-bundle.sh b/packaging/build-release-bundle.sh
new file mode 100755
index 0000000..10e6025
--- /dev/null
+++ b/packaging/build-release-bundle.sh
@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+root_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+package_id="$(cargo pkgid --manifest-path "${root_dir}/Cargo.toml")"
+version="${package_id##*@}"
+artifact_name="Comicviewer-${version}-x86_64"
+bundle_name="Comicviewer-latest-x86_64"
+appimage_name="${artifact_name}.AppImage"
+appimage="${root_dir}/dist/${appimage_name}"
+checksum="${appimage}.sha256"
+archive="${root_dir}/dist/${bundle_name}.tar.gz"
+archive_checksum="${archive}.sha256"
+work_dir="$(mktemp -d)"
+bundle_dir="${work_dir}/${bundle_name}"
+archive_mtime="${SOURCE_DATE_EPOCH:-$(git -C "${root_dir}" log -1 --format=%ct)}"
+
+cleanup() {
+ rm -rf "${work_dir}"
+}
+trap cleanup EXIT
+
+if [[ ! -f "${appimage}" ]]; then
+ printf 'AppImage가 없습니다: %s\n' "${appimage}" >&2
+ printf '%s\n' "먼저 packaging/build-appimage.sh를 실행하세요." >&2
+ exit 1
+fi
+
+mkdir -p "${bundle_dir}"
+(
+ cd "${root_dir}/dist"
+ sha256sum "${appimage_name}" > "${appimage_name}.sha256"
+)
+
+install -m 0755 "${appimage}" "${bundle_dir}/${appimage_name}"
+install -m 0644 "${checksum}" "${bundle_dir}/${appimage_name}.sha256"
+install -m 0755 \
+ "${root_dir}/packaging/install-or-update.sh" \
+ "${bundle_dir}/install-or-update.sh"
+install -m 0644 \
+ "${root_dir}/data/io.github.comicviewer.Comicviewer.desktop" \
+ "${bundle_dir}/io.github.comicviewer.Comicviewer.desktop"
+install -m 0644 \
+ "${root_dir}/data/io.github.comicviewer.Comicviewer.svg" \
+ "${bundle_dir}/io.github.comicviewer.Comicviewer.svg"
+install -m 0644 "${root_dir}/docs/INSTALL.ko.md" "${bundle_dir}/README.ko.md"
+
+tar --sort=name --owner=0 --group=0 --numeric-owner --mtime="@${archive_mtime}" \
+ -C "${work_dir}" -cf - "${bundle_name}" | gzip -n > "${archive}"
+(
+ cd "${root_dir}/dist"
+ sha256sum "$(basename "${archive}")" > "$(basename "${archive_checksum}")"
+)
+
+printf 'Created %s\n' "${archive}"
+printf 'Created %s\n' "${archive_checksum}"
diff --git a/packaging/install-or-update.sh b/packaging/install-or-update.sh
new file mode 100755
index 0000000..fbc1893
--- /dev/null
+++ b/packaging/install-or-update.sh
@@ -0,0 +1,127 @@
+#!/usr/bin/env sh
+set -eu
+
+app_id="io.github.comicviewer.Comicviewer"
+script_dir="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+install_dir="${HOME}/.local/opt/comicviewer"
+bin_dir="${HOME}/.local/bin"
+data_home="${XDG_DATA_HOME:-${HOME}/.local/share}"
+config_home="${XDG_CONFIG_HOME:-${HOME}/.config}"
+cache_home="${XDG_CACHE_HOME:-${HOME}/.cache}"
+applications_dir="${data_home}/applications"
+icons_dir="${data_home}/icons/hicolor/scalable/apps"
+installed_appimage="${install_dir}/Comicviewer.AppImage"
+launcher="${bin_dir}/comicviewer"
+installed_desktop="${applications_dir}/${app_id}.desktop"
+installed_icon="${icons_dir}/${app_id}.svg"
+temporary_appimage=""
+temporary_desktop=""
+
+cleanup() {
+ [ -z "${temporary_appimage}" ] || rm -f "${temporary_appimage}"
+ [ -z "${temporary_desktop}" ] || rm -f "${temporary_desktop}"
+}
+trap cleanup EXIT HUP INT TERM
+
+refresh_desktop() {
+ if command -v update-desktop-database >/dev/null 2>&1; then
+ update-desktop-database "${applications_dir}" >/dev/null 2>&1 || true
+ fi
+}
+
+install_dependencies() {
+ if [ "${COMICVIEWER_SKIP_DEPENDENCIES:-0}" = "1" ]; then
+ return
+ fi
+ if ! command -v pacman >/dev/null 2>&1; then
+ printf '%s\n' "필수 패키지 자동 설치는 Arch Linux와 CachyOS만 지원합니다." >&2
+ exit 1
+ fi
+
+ set --
+ for package in fuse2 gtk4 dav1d gvfs gvfs-smb gstreamer curl gst-plugins-base \
+ gst-plugins-good gst-plugins-bad gst-libav; do
+ if ! pacman -Q "${package}" >/dev/null 2>&1; then
+ set -- "$@" "${package}"
+ fi
+ done
+ if [ "$#" -eq 0 ]; then
+ return
+ fi
+
+ printf '필수 패키지를 설치합니다: %s\n' "$*"
+ if [ "$(id -u)" -eq 0 ]; then
+ pacman -S --needed "$@"
+ else
+ if ! command -v sudo >/dev/null 2>&1; then
+ printf '%s\n' "필수 패키지를 설치하려면 sudo가 필요합니다." >&2
+ exit 1
+ fi
+ sudo pacman -S --needed "$@"
+ fi
+}
+
+if [ "${1:-}" = "--uninstall" ]; then
+ rm -f "${launcher}" "${installed_desktop}" "${installed_icon}" \
+ "${installed_appimage}"
+ rm -rf "${config_home}/comicviewer" "${data_home}/comicviewer" \
+ "${cache_home}/comicviewer"
+ rmdir "${install_dir}" 2>/dev/null || true
+ refresh_desktop
+ printf '%s\n' "Comicviewer와 설정, 읽기 기록, 캐시를 모두 제거했습니다."
+ exit 0
+fi
+
+if [ "$#" -ne 0 ]; then
+ printf '사용법: %s [--uninstall]\n' "$(basename -- "$0")" >&2
+ exit 2
+fi
+
+install_dependencies
+
+set -- "${script_dir}"/Comicviewer-*-x86_64.AppImage
+if [ "$#" -ne 1 ] || [ ! -f "$1" ]; then
+ printf '%s\n' "번들에서 Comicviewer AppImage 한 개를 찾을 수 없습니다." >&2
+ exit 1
+fi
+
+appimage="$1"
+checksum="${appimage}.sha256"
+desktop_file="${script_dir}/${app_id}.desktop"
+icon_file="${script_dir}/${app_id}.svg"
+
+for required_file in "${checksum}" "${desktop_file}" "${icon_file}"; do
+ if [ ! -f "${required_file}" ]; then
+ printf '필수 파일이 없습니다: %s\n' "$(basename -- "${required_file}")" >&2
+ exit 1
+ fi
+done
+
+(cd "${script_dir}" && sha256sum -c "$(basename -- "${checksum}")")
+
+mkdir -p "${install_dir}" "${bin_dir}" "${applications_dir}" "${icons_dir}"
+temporary_appimage="${install_dir}/.Comicviewer.AppImage.tmp.$$"
+temporary_desktop="${applications_dir}/.${app_id}.desktop.tmp.$$"
+
+install -m 0755 "${appimage}" "${temporary_appimage}"
+mv -f "${temporary_appimage}" "${installed_appimage}"
+temporary_appimage=""
+ln -sfn "${installed_appimage}" "${launcher}"
+while IFS= read -r line || [ -n "${line}" ]; do
+ case "${line}" in
+ Exec=*) printf 'Exec="%s" %%f\n' "${launcher}" ;;
+ *) printf '%s\n' "${line}" ;;
+ esac
+done < "${desktop_file}" > "${temporary_desktop}"
+chmod 0644 "${temporary_desktop}"
+mv -f "${temporary_desktop}" "${installed_desktop}"
+temporary_desktop=""
+install -m 0644 "${icon_file}" "${installed_icon}"
+refresh_desktop
+
+if ! command -v gio >/dev/null 2>&1; then
+ printf '%s\n' "주의: 원격 파일 접근을 위해 gvfs와 gvfs-smb를 설치하세요." >&2
+fi
+
+printf '%s\n' "Comicviewer 설치 또는 업데이트를 완료했습니다."
+printf '실행: %s\n' "${launcher}"
diff --git a/src/archive.rs b/src/archive.rs
index 04e6090..eb7f661 100644
--- a/src/archive.rs
+++ b/src/archive.rs
@@ -1,16 +1,23 @@
use std::fs::File;
use std::io::{Cursor, Read};
use std::path::Path;
+use std::time::Duration;
use anyhow::{Context, Result, bail};
-use image::ImageReader;
+use image::codecs::gif::GifDecoder;
+use image::codecs::webp::WebPDecoder;
+use image::metadata::LoopCount;
+use image::{AnimationDecoder, ImageFormat, ImageReader};
use zip::ZipArchive;
-use crate::browser::natural_cmp;
+use crate::browser::natural_cmp_with_case;
const MAX_ENTRY_SIZE: u64 = 256 * 1024 * 1024;
const MAX_IMAGE_DIMENSION: u32 = 30_000;
const MAX_IMAGE_PIXELS: u64 = 100_000_000;
+const MAX_ANIMATION_FRAMES: usize = 1_000;
+const MAX_ANIMATION_BYTES: usize = 512 * 1024 * 1024;
+const MIN_FRAME_DELAY: Duration = Duration::from_millis(10);
#[derive(Debug, Clone)]
pub struct ArchivePage {
@@ -21,10 +28,16 @@ pub struct ArchivePage {
pub struct DecodedPage {
pub width: u32,
pub height: u32,
- pub rgba: Vec,
+ pub frames: Vec,
+ pub loop_count: Option,
}
-pub fn list_pages(path: &Path) -> Result> {
+pub struct DecodedFrame {
+ pub rgba: Vec,
+ pub delay: Duration,
+}
+
+pub fn list_pages(path: &Path, case_insensitive: bool) -> Result> {
let file = File::open(path)
.with_context(|| format!("ZIP 파일을 열 수 없습니다: {}", path.display()))?;
let mut archive = ZipArchive::new(file)
@@ -41,7 +54,7 @@ pub fn list_pages(path: &Path) -> Result> {
}
}
- pages.sort_by(|left, right| natural_cmp(&left.name, &right.name));
+ pages.sort_by(|left, right| natural_cmp_with_case(&left.name, &right.name, case_insensitive));
Ok(pages)
}
@@ -70,25 +83,123 @@ pub fn decode_page(path: &Path, page: &ArchivePage) -> Result {
bail!("실제 압축 해제 크기가 제한을 초과합니다: {}", page.name);
}
- let reader = ImageReader::new(Cursor::new(&encoded))
+ decode_image_bytes(&encoded, &page.name)
+}
+
+pub fn decode_image_file(path: &Path, display_name: &str) -> Result {
+ let file = File::open(path)
+ .with_context(|| format!("이미지 파일을 열 수 없습니다: {display_name}"))?;
+ let mut encoded = Vec::new();
+ file.take(MAX_ENTRY_SIZE + 1)
+ .read_to_end(&mut encoded)
+ .with_context(|| format!("이미지 파일을 읽을 수 없습니다: {display_name}"))?;
+ if encoded.len() as u64 > MAX_ENTRY_SIZE {
+ bail!("이미지 크기가 제한을 초과합니다: {display_name} (최대 256MB)");
+ }
+ decode_image_bytes(&encoded, display_name)
+}
+
+fn decode_image_bytes(encoded: &[u8], name: &str) -> Result {
+ let reader = ImageReader::new(Cursor::new(encoded))
.with_guessed_format()
- .with_context(|| format!("이미지 형식을 확인할 수 없습니다: {}", page.name))?;
+ .with_context(|| format!("이미지 형식을 확인할 수 없습니다: {name}"))?;
+ let format = reader.format();
let (width, height) = reader
.into_dimensions()
- .with_context(|| format!("이미지 크기를 읽을 수 없습니다: {}", page.name))?;
- validate_dimensions(width, height, &page.name)?;
+ .with_context(|| format!("이미지 크기를 읽을 수 없습니다: {name}"))?;
+ validate_dimensions(width, height, name)?;
- let image = image::load_from_memory(&encoded)
- .with_context(|| format!("이미지를 디코딩할 수 없습니다: {}", page.name))?;
+ let animated = match format {
+ Some(ImageFormat::Gif) => {
+ let decoder = GifDecoder::new(Cursor::new(encoded))
+ .with_context(|| format!("GIF를 디코딩할 수 없습니다: {name}"))?;
+ let loop_count = animation_loop_count(decoder.loop_count());
+ Some((decoder.into_frames(), loop_count))
+ }
+ Some(ImageFormat::WebP) => {
+ let decoder = WebPDecoder::new(Cursor::new(encoded))
+ .with_context(|| format!("WebP를 디코딩할 수 없습니다: {name}"))?;
+ decoder.has_animation().then(|| {
+ let loop_count = animation_loop_count(decoder.loop_count());
+ (decoder.into_frames(), loop_count)
+ })
+ }
+ _ => None,
+ };
+ if let Some((frames, loop_count)) = animated {
+ return decoded_animation(width, height, frames, loop_count, name);
+ }
+
+ let image = image::load_from_memory(encoded)
+ .with_context(|| format!("이미지를 디코딩할 수 없습니다: {name}"))?;
let rgba = image.into_rgba8();
Ok(DecodedPage {
width,
height,
- rgba: rgba.into_raw(),
+ frames: vec![DecodedFrame {
+ rgba: rgba.into_raw(),
+ delay: Duration::ZERO,
+ }],
+ loop_count: Some(1),
})
}
+fn decoded_animation(
+ width: u32,
+ height: u32,
+ frames: impl Iterator- >,
+ loop_count: Option,
+ name: &str,
+) -> Result {
+ let expected_bytes = usize::try_from(width)?
+ .checked_mul(usize::try_from(height)?)
+ .and_then(|pixels| pixels.checked_mul(4))
+ .context("애니메이션 프레임 크기를 처리할 수 없습니다")?;
+ let mut decoded = Vec::new();
+ let mut total_bytes = 0_usize;
+ for (index, frame) in frames.enumerate() {
+ if index >= MAX_ANIMATION_FRAMES {
+ bail!(
+ "애니메이션 프레임 수가 제한을 초과합니다: {name} (최대 {MAX_ANIMATION_FRAMES}개)"
+ );
+ }
+ let frame =
+ frame.with_context(|| format!("애니메이션 프레임을 디코딩할 수 없습니다: {name}"))?;
+ total_bytes = total_bytes
+ .checked_add(expected_bytes)
+ .context("애니메이션 전체 크기를 처리할 수 없습니다")?;
+ if total_bytes > MAX_ANIMATION_BYTES {
+ bail!("애니메이션 디코딩 크기가 제한을 초과합니다: {name} (최대 512MB)");
+ }
+ let delay = Duration::from(frame.delay()).max(MIN_FRAME_DELAY);
+ let rgba = frame.into_buffer();
+ if rgba.dimensions() != (width, height) || rgba.len() != expected_bytes {
+ bail!("애니메이션 프레임 크기가 일치하지 않습니다: {name}");
+ }
+ decoded.push(DecodedFrame {
+ rgba: rgba.into_raw(),
+ delay,
+ });
+ }
+ if decoded.is_empty() {
+ bail!("애니메이션에 표시할 프레임이 없습니다: {name}");
+ }
+ Ok(DecodedPage {
+ width,
+ height,
+ frames: decoded,
+ loop_count,
+ })
+}
+
+fn animation_loop_count(loop_count: LoopCount) -> Option {
+ match loop_count {
+ LoopCount::Infinite => None,
+ LoopCount::Finite(count) => Some(count.get()),
+ }
+}
+
fn validate_dimensions(width: u32, height: u32, name: &str) -> Result<()> {
let pixels = u64::from(width) * u64::from(height);
if width == 0
@@ -161,7 +272,7 @@ mod tests {
archive.write_all(b"ignored").unwrap();
archive.finish().unwrap();
- let pages = list_pages(&path).unwrap();
+ let pages = list_pages(&path, true).unwrap();
assert_eq!(
pages
.iter()
@@ -171,8 +282,51 @@ mod tests {
);
let decoded = decode_page(&path, &pages[0]).unwrap();
assert_eq!((decoded.width, decoded.height), (2, 3));
- assert_eq!(decoded.rgba.len(), 2 * 3 * 4);
+ assert_eq!(decoded.frames[0].rgba.len(), 2 * 3 * 4);
std::fs::remove_file(path).unwrap();
}
+
+ #[test]
+ fn decodes_a_standalone_image() {
+ let directory = tempfile::tempdir().unwrap();
+ let path = directory.path().join("photo.png");
+ let image = image::RgbaImage::from_pixel(4, 5, image::Rgba([1, 2, 3, 255]));
+ image.save(&path).unwrap();
+
+ let decoded = decode_image_file(&path, "photo.png").unwrap();
+ assert_eq!((decoded.width, decoded.height), (4, 5));
+ assert_eq!(decoded.frames[0].rgba.len(), 4 * 5 * 4);
+ }
+
+ #[test]
+ fn decodes_all_animated_gif_frames() {
+ let mut encoded = Vec::new();
+ let first = image::Frame::from_parts(
+ image::RgbaImage::from_pixel(2, 1, image::Rgba([255, 0, 0, 255])),
+ 0,
+ 0,
+ image::Delay::from_numer_denom_ms(20, 1),
+ );
+ let second = image::Frame::from_parts(
+ image::RgbaImage::from_pixel(2, 1, image::Rgba([0, 0, 255, 255])),
+ 0,
+ 0,
+ image::Delay::from_numer_denom_ms(30, 1),
+ );
+ let mut encoder = image::codecs::gif::GifEncoder::new(&mut encoded);
+ encoder
+ .set_repeat(image::codecs::gif::Repeat::Finite(2))
+ .unwrap();
+ encoder.encode_frames([first, second]).unwrap();
+ drop(encoder);
+
+ let decoded = decode_image_bytes(&encoded, "animated.gif").unwrap();
+
+ assert_eq!(decoded.frames.len(), 2);
+ assert_eq!(decoded.frames[0].delay, Duration::from_millis(20));
+ assert_eq!(decoded.frames[1].delay, Duration::from_millis(30));
+ assert_eq!(decoded.loop_count, Some(2));
+ assert_ne!(decoded.frames[0].rgba, decoded.frames[1].rgba);
+ }
}
diff --git a/src/browser.rs b/src/browser.rs
index 1613747..65b5d8a 100644
--- a/src/browser.rs
+++ b/src/browser.rs
@@ -6,12 +6,22 @@ use std::time::SystemTime;
pub enum EntryKind {
Directory,
ZipArchive,
+ Image,
+ Video,
+ OtherFile,
+}
+
+impl EntryKind {
+ pub fn is_viewable(self) -> bool {
+ matches!(self, Self::ZipArchive | Self::Image | Self::Video)
+ }
}
#[derive(Debug, Clone)]
pub struct BrowserEntry {
pub uri: String,
pub name: String,
+ pub list_name: Option,
pub kind: EntryKind,
pub size: Option,
pub modified: Option,
@@ -19,6 +29,12 @@ pub struct BrowserEntry {
pub etag: Option,
}
+impl BrowserEntry {
+ pub fn display_name(&self) -> &str {
+ self.list_name.as_deref().unwrap_or(&self.name)
+ }
+}
+
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SortField {
Name,
@@ -32,11 +48,19 @@ pub enum SortDirection {
Descending,
}
-pub fn sort_entries(entries: &mut [BrowserEntry], field: SortField, direction: SortDirection) {
+pub fn sort_entries(
+ entries: &mut [BrowserEntry],
+ field: SortField,
+ direction: SortDirection,
+ case_insensitive: bool,
+) {
entries.sort_by(|left, right| {
- let kind_order = match (left.kind, right.kind) {
- (EntryKind::Directory, EntryKind::ZipArchive) => Ordering::Less,
- (EntryKind::ZipArchive, EntryKind::Directory) => Ordering::Greater,
+ let kind_order = match (
+ left.kind == EntryKind::Directory,
+ right.kind == EntryKind::Directory,
+ ) {
+ (true, false) => Ordering::Less,
+ (false, true) => Ordering::Greater,
_ => Ordering::Equal,
};
if kind_order != Ordering::Equal {
@@ -44,11 +68,32 @@ pub fn sort_entries(entries: &mut [BrowserEntry], field: SortField, direction: S
}
match field {
- SortField::Name => apply_direction(natural_cmp(&left.name, &right.name), direction),
+ SortField::Name => apply_direction(
+ natural_cmp_with_case(left.display_name(), right.display_name(), case_insensitive),
+ direction,
+ ),
SortField::Modified => compare_optional_time(left.modified, right.modified, direction)
- .then_with(|| apply_direction(natural_cmp(&left.name, &right.name), direction)),
+ .then_with(|| {
+ apply_direction(
+ natural_cmp_with_case(
+ left.display_name(),
+ right.display_name(),
+ case_insensitive,
+ ),
+ direction,
+ )
+ }),
SortField::Created => compare_optional_time(left.created, right.created, direction)
- .then_with(|| apply_direction(natural_cmp(&left.name, &right.name), direction)),
+ .then_with(|| {
+ apply_direction(
+ natural_cmp_with_case(
+ left.display_name(),
+ right.display_name(),
+ case_insensitive,
+ ),
+ direction,
+ )
+ }),
}
});
}
@@ -73,19 +118,28 @@ fn apply_direction(order: Ordering, direction: SortDirection) -> Ordering {
}
}
-pub fn is_zip_path(path: &Path) -> bool {
- path.extension()
+pub fn classify_file(path: &Path) -> EntryKind {
+ let extension = path
+ .extension()
.and_then(|extension| extension.to_str())
- .is_some_and(|extension| extension.eq_ignore_ascii_case("zip"))
+ .map(str::to_ascii_lowercase);
+ match extension.as_deref() {
+ Some("zip") => EntryKind::ZipArchive,
+ Some("jpg" | "jpeg" | "png" | "webp" | "gif" | "bmp" | "avif") => EntryKind::Image,
+ Some("mp4" | "m4v" | "mkv" | "webm" | "mov" | "avi" | "mpeg" | "mpg" | "ogv") => {
+ EntryKind::Video
+ }
+ _ => EntryKind::OtherFile,
+ }
}
-pub fn natural_cmp(left: &str, right: &str) -> Ordering {
+pub fn natural_cmp_with_case(left: &str, right: &str, case_insensitive: bool) -> Ordering {
let mut left_chars = left.chars().peekable();
let mut right_chars = right.chars().peekable();
loop {
match (left_chars.peek(), right_chars.peek()) {
- (None, None) => return Ordering::Equal,
+ (None, None) => return left.cmp(right),
(None, Some(_)) => return Ordering::Less,
(Some(_), None) => return Ordering::Greater,
(Some(left_char), Some(right_char))
@@ -118,10 +172,11 @@ pub fn natural_cmp(left: &str, right: &str) -> Ordering {
(Some(_), Some(_)) => {
let left_char = left_chars.next().unwrap();
let right_char = right_chars.next().unwrap();
- let order = left_char
- .to_lowercase()
- .cmp(right_char.to_lowercase())
- .then_with(|| left_char.cmp(&right_char));
+ let order = if case_insensitive {
+ left_char.to_lowercase().cmp(right_char.to_lowercase())
+ } else {
+ left_char.cmp(&right_char)
+ };
if order != Ordering::Equal {
return order;
}
@@ -148,22 +203,67 @@ mod tests {
#[test]
fn natural_order_places_two_before_ten() {
let mut names = ["page10.jpg", "page2.jpg", "page1.jpg"];
- names.sort_by(|left, right| natural_cmp(left, right));
+ names.sort_by(|left, right| natural_cmp_with_case(left, right, true));
assert_eq!(names, ["page1.jpg", "page2.jpg", "page10.jpg"]);
}
#[test]
fn natural_order_handles_numbers_larger_than_integers() {
assert_eq!(
- natural_cmp("9.zip", "123456789012345678901234567890.zip"),
+ natural_cmp_with_case("9.zip", "123456789012345678901234567890.zip", true),
Ordering::Less
);
}
+ #[test]
+ fn natural_order_can_ignore_or_respect_case() {
+ assert_eq!(
+ natural_cmp_with_case("a2.jpg", "A10.jpg", true),
+ Ordering::Less
+ );
+ assert_eq!(
+ natural_cmp_with_case("a2.jpg", "A10.jpg", false),
+ Ordering::Greater
+ );
+ }
+
+ #[test]
+ fn recursive_entries_sort_by_relative_display_path() {
+ let mut entries = ["10권/page.jpg", "2권/page.jpg"].map(|list_name| BrowserEntry {
+ uri: format!("file:///{list_name}"),
+ name: "page.jpg".into(),
+ list_name: Some(list_name.into()),
+ kind: EntryKind::Image,
+ size: None,
+ modified: None,
+ created: None,
+ etag: None,
+ });
+
+ sort_entries(
+ &mut entries,
+ SortField::Name,
+ SortDirection::Ascending,
+ true,
+ );
+
+ assert_eq!(entries[0].display_name(), "2권/page.jpg");
+ assert_eq!(entries[1].display_name(), "10권/page.jpg");
+ }
+
#[test]
fn zip_extension_is_case_insensitive() {
- assert!(is_zip_path(Path::new("comic.ZIP")));
- assert!(!is_zip_path(Path::new("comic.cbz")));
+ assert_eq!(classify_file(Path::new("comic.ZIP")), EntryKind::ZipArchive);
+ assert_ne!(classify_file(Path::new("comic.cbz")), EntryKind::ZipArchive);
+ }
+
+ #[test]
+ fn classifies_common_media_extensions_case_insensitively() {
+ assert_eq!(classify_file(Path::new("photo.JPG")), EntryKind::Image);
+ assert_eq!(classify_file(Path::new("animation.webp")), EntryKind::Image);
+ assert_eq!(classify_file(Path::new("movie.MP4")), EntryKind::Video);
+ assert_eq!(classify_file(Path::new("movie.mkv")), EntryKind::Video);
+ assert_eq!(classify_file(Path::new("notes.txt")), EntryKind::OtherFile);
}
#[test]
diff --git a/src/config.rs b/src/config.rs
index 0471dd2..905b382 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -10,7 +10,12 @@ use serde::{Deserialize, Serialize};
pub struct AppConfig {
pub cache_quota_gb: u64,
pub fast_image_loading: bool,
+ pub case_insensitive_sort: bool,
+ pub viewer_mode: ViewerMode,
+ pub two_page_right_to_left: bool,
pub locations: Vec,
+ pub favorites: Vec,
+ pub recent_files: Vec,
}
impl Default for AppConfig {
@@ -18,7 +23,12 @@ impl Default for AppConfig {
Self {
cache_quota_gb: 10,
fast_image_loading: true,
+ case_insensitive_sort: true,
+ viewer_mode: ViewerMode::FitWidth,
+ two_page_right_to_left: true,
locations: Vec::new(),
+ favorites: Vec::new(),
+ recent_files: Vec::new(),
}
}
}
@@ -36,6 +46,21 @@ pub struct LocationProfile {
pub domain: String,
}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FavoriteEntry {
+ pub name: String,
+ pub uri: String,
+ pub is_directory: bool,
+ pub profile: LocationProfile,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RecentFileEntry {
+ pub name: String,
+ pub uri: String,
+ pub profile: LocationProfile,
+}
+
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum LocationKind {
@@ -45,6 +70,39 @@ pub enum LocationKind {
Sftp,
}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum ViewerMode {
+ ActualSize,
+ #[default]
+ FitWidth,
+ FitHeight,
+ TwoPage,
+ Continuous,
+}
+
+impl ViewerMode {
+ pub fn dropdown_index(self) -> u32 {
+ match self {
+ Self::ActualSize => 0,
+ Self::FitWidth => 1,
+ Self::FitHeight => 2,
+ Self::TwoPage => 3,
+ Self::Continuous => 4,
+ }
+ }
+
+ pub fn from_dropdown_index(index: u32) -> Self {
+ match index {
+ 0 => Self::ActualSize,
+ 2 => Self::FitHeight,
+ 3 => Self::TwoPage,
+ 4 => Self::Continuous,
+ _ => Self::FitWidth,
+ }
+ }
+}
+
impl AppConfig {
pub fn load_or_create(path: &Path) -> Result {
if path.exists() {
@@ -122,6 +180,7 @@ mod tests {
#[test]
fn default_cache_quota_is_ten_gigabytes() {
assert_eq!(AppConfig::default().cache_quota_gb, 10);
+ assert!(AppConfig::default().case_insensitive_sort);
}
#[test]
@@ -129,6 +188,9 @@ mod tests {
let config = AppConfig {
cache_quota_gb: 0,
fast_image_loading: true,
+ case_insensitive_sort: true,
+ viewer_mode: ViewerMode::FitWidth,
+ two_page_right_to_left: true,
locations: vec![LocationProfile {
name: "테스트".into(),
kind: LocationKind::Sftp,
@@ -137,16 +199,77 @@ mod tests {
password: "plain-password".into(),
domain: String::new(),
}],
+ favorites: vec![FavoriteEntry {
+ name: "원격 만화".into(),
+ uri: "sftp://example.invalid/comics/book.zip".into(),
+ is_directory: false,
+ profile: LocationProfile {
+ name: "즐겨찾기 서버".into(),
+ kind: LocationKind::Sftp,
+ address: "sftp://example.invalid/comics".into(),
+ username: "favorite-reader".into(),
+ password: "favorite-password".into(),
+ domain: String::new(),
+ },
+ }],
+ recent_files: vec![RecentFileEntry {
+ name: "최근 영상.mp4".into(),
+ uri: "sftp://example.invalid/comics/recent.mp4".into(),
+ profile: LocationProfile {
+ name: "최근 서버".into(),
+ kind: LocationKind::Sftp,
+ address: "sftp://example.invalid/comics".into(),
+ username: "recent-reader".into(),
+ password: "recent-password".into(),
+ domain: String::new(),
+ },
+ }],
};
let encoded = toml::to_string(&config).unwrap();
let decoded: AppConfig = toml::from_str(&encoded).unwrap();
assert_eq!(decoded.locations[0].password, "plain-password");
+ assert_eq!(decoded.favorites[0].profile.username, "favorite-reader");
+ assert_eq!(decoded.favorites[0].profile.password, "favorite-password");
+ assert_eq!(decoded.recent_files[0].profile.username, "recent-reader");
+ assert_eq!(decoded.recent_files[0].profile.password, "recent-password");
}
#[test]
fn fast_image_loading_is_enabled_for_existing_configs() {
let decoded: AppConfig = toml::from_str("cache_quota_gb = 10\n").unwrap();
assert!(decoded.fast_image_loading);
+ assert!(decoded.case_insensitive_sort);
+ assert_eq!(decoded.viewer_mode, ViewerMode::FitWidth);
+ assert!(decoded.two_page_right_to_left);
+ assert!(decoded.favorites.is_empty());
+ assert!(decoded.recent_files.is_empty());
+ }
+
+ #[test]
+ fn viewer_modes_round_trip_through_dropdown_indices() {
+ for mode in [
+ ViewerMode::ActualSize,
+ ViewerMode::FitWidth,
+ ViewerMode::FitHeight,
+ ViewerMode::TwoPage,
+ ViewerMode::Continuous,
+ ] {
+ assert_eq!(ViewerMode::from_dropdown_index(mode.dropdown_index()), mode);
+ }
+ assert_eq!(ViewerMode::from_dropdown_index(99), ViewerMode::FitWidth);
+ }
+
+ #[test]
+ fn two_page_direction_defaults_to_rtl_and_round_trips_ltr() {
+ let existing: AppConfig = toml::from_str("cache_quota_gb = 10\n").unwrap();
+ assert!(existing.two_page_right_to_left);
+
+ let config = AppConfig {
+ two_page_right_to_left: false,
+ ..AppConfig::default()
+ };
+ let decoded: AppConfig = toml::from_str(&toml::to_string(&config).unwrap()).unwrap();
+ assert!(!decoded.two_page_right_to_left);
}
}
diff --git a/src/main.rs b/src/main.rs
index f48b1a6..dccd524 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -8,36 +8,86 @@ mod viewer;
mod window;
mod zip_cache;
+use std::cell::RefCell;
+use std::rc::Rc;
+
use anyhow::Result;
+use gtk::gio;
use gtk::prelude::*;
const APP_ID: &str = "io.github.comicviewer.Comicviewer";
fn main() {
- let application = gtk::Application::builder().application_id(APP_ID).build();
+ let application = gtk::Application::builder()
+ .application_id(APP_ID)
+ .flags(application_flags())
+ .build();
+ let state = Rc::new(ApplicationState::default());
- application.connect_activate(|application| {
- if let Err(error) = activate(application) {
- eprintln!("Comicviewer를 시작하지 못했습니다: {error:#}");
- application.quit();
+ let activate_state = Rc::clone(&state);
+ application.connect_activate(move |application| {
+ match activate_state.ensure_main_window(application) {
+ Ok(window) => window.present(),
+ Err(error) => startup_failed(application, &error),
+ }
+ });
+ application.connect_open(move |application, files, _| {
+ match state.ensure_main_window(application) {
+ Ok(window) => window.open_local_items(files),
+ Err(error) => startup_failed(application, &error),
}
});
application.run();
}
-fn activate(application: >k::Application) -> Result<()> {
- let app_paths = paths::AppPaths::discover()?;
- let config = config::AppConfig::load_or_create(&app_paths.config_file)?;
- let database = database::Database::open(&app_paths.database_file)?;
- let zip_cache = zip_cache::ZipCache::new(app_paths.zip_cache_dir, config.cache_quota_gb)?;
- let window = window::ComicWindow::new(
- application,
- config,
- app_paths.config_file,
- database,
- zip_cache,
- )?;
- window.present();
- Ok(())
+#[derive(Default)]
+struct ApplicationState {
+ main_window: RefCell>>,
+}
+
+impl ApplicationState {
+ fn ensure_main_window(
+ &self,
+ application: >k::Application,
+ ) -> Result> {
+ if let Some(window) = self.main_window.borrow().as_ref() {
+ return Ok(Rc::clone(window));
+ }
+ let app_paths = paths::AppPaths::discover()?;
+ let config = config::AppConfig::load_or_create(&app_paths.config_file)?;
+ let database = database::Database::open(&app_paths.database_file)?;
+ let zip_cache = zip_cache::ZipCache::new(app_paths.zip_cache_dir, config.cache_quota_gb)?;
+ let window = Rc::new(window::ComicWindow::new(
+ application,
+ config,
+ app_paths.config_file,
+ database,
+ zip_cache,
+ )?);
+ self.main_window.replace(Some(Rc::clone(&window)));
+ Ok(window)
+ }
+}
+
+fn startup_failed(application: >k::Application, error: &anyhow::Error) {
+ eprintln!("Comicviewer를 시작하지 못했습니다: {error:#}");
+ application.quit();
+}
+
+fn application_flags() -> gio::ApplicationFlags {
+ gio::ApplicationFlags::HANDLES_OPEN
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn application_accepts_files_as_a_single_instance() {
+ let flags = application_flags();
+ assert!(flags.contains(gio::ApplicationFlags::HANDLES_OPEN));
+ assert!(!flags.contains(gio::ApplicationFlags::NON_UNIQUE));
+ assert!(!flags.contains(gio::ApplicationFlags::HANDLES_COMMAND_LINE));
+ }
}
diff --git a/src/source.rs b/src/source.rs
index d9aab4a..bf6b8e2 100644
--- a/src/source.rs
+++ b/src/source.rs
@@ -1,3 +1,4 @@
+use std::collections::{HashSet, VecDeque};
use std::path::Path;
use std::time::{Duration, UNIX_EPOCH};
@@ -7,10 +8,47 @@ use gtk::gio::prelude::*;
use gtk::glib;
use percent_encoding::percent_decode_str;
-use crate::browser::{BrowserEntry, EntryKind, is_zip_path};
+use crate::browser::{BrowserEntry, EntryKind, classify_file};
use crate::config::{LocationKind, LocationProfile};
const ATTRIBUTES: &str = "standard::display-name,standard::name,standard::type,standard::size,standard::target-uri,mountable::can-mount,time::modified,time::created,etag::value";
+const RECURSIVE_ATTRIBUTES: &str = "standard::display-name,standard::name,standard::type,standard::is-symlink,standard::size,time::modified,time::created,etag::value,id::file,id::filesystem";
+const MAX_RECURSIVE_DIRECTORIES: usize = 10_000;
+const MAX_RECURSIVE_ENTRIES: usize = 100_000;
+
+#[derive(Default)]
+struct EnumerationProgress {
+ seen: HashSet,
+ new_in_batch: usize,
+}
+
+impl EnumerationProgress {
+ fn begin_batch(&mut self) {
+ self.new_in_batch = 0;
+ }
+
+ fn record(&mut self, uri: String) -> bool {
+ let inserted = self.seen.insert(uri);
+ self.new_in_batch += usize::from(inserted);
+ inserted
+ }
+
+ fn repeated_batch(&self) -> bool {
+ self.new_in_batch == 0
+ }
+
+ fn len(&self) -> usize {
+ self.seen.len()
+ }
+}
+
+#[derive(Clone, Copy, Default)]
+pub struct RecursiveProgress {
+ pub directories: usize,
+ pub scanned: usize,
+ pub viewable: usize,
+ pub skipped: usize,
+}
pub fn root_file(profile: &LocationProfile) -> Result {
validate_profile(profile)?;
@@ -100,7 +138,7 @@ where
}
};
let mut entries = Vec::new();
- let mut scanned = 0;
+ let mut enumeration = EnumerationProgress::default();
loop {
let batch = enumerator
@@ -109,24 +147,25 @@ where
if batch.is_empty() {
break;
}
- scanned += batch.len();
- progress(scanned);
+ enumeration.begin_batch();
for info in batch {
+ let child = enumerator.child(&info);
+ let uri: String = info
+ .attribute_string("standard::target-uri")
+ .map_or_else(|| child.uri().into(), Into::into);
+ if !enumeration.record(uri.clone()) {
+ continue;
+ }
let kind = match info.file_type() {
gio::FileType::Directory => EntryKind::Directory,
gio::FileType::Mountable | gio::FileType::Shortcut => EntryKind::Directory,
- gio::FileType::Regular if is_zip_path(Path::new(info.display_name().as_str())) => {
- EntryKind::ZipArchive
- }
+ gio::FileType::Regular => classify_file(Path::new(info.display_name().as_str())),
_ => continue,
};
- let child = enumerator.child(&info);
- let uri = info
- .attribute_string("standard::target-uri")
- .map_or_else(|| child.uri().into(), Into::into);
entries.push(BrowserEntry {
uri,
name: info.display_name().into(),
+ list_name: None,
kind,
size: info
.has_attribute("standard::size")
@@ -142,10 +181,151 @@ where
.map(Into::into),
});
}
+ if enumeration.repeated_batch() {
+ break;
+ }
+ progress(enumeration.len());
}
Ok(entries)
}
+pub async fn enumerate_tree_entries(
+ profile: &LocationProfile,
+ root: &gio::File,
+ operation: Option<>k::MountOperation>,
+ mut progress: F,
+) -> Result<(Vec, RecursiveProgress)>
+where
+ F: FnMut(RecursiveProgress),
+{
+ if profile.kind != LocationKind::Local && !root.is_native() {
+ let operation = operation.context("원격 폴더 마운트 정보가 없습니다")?;
+ ensure_mounted(root, profile, operation).await?;
+ }
+ let mut pending = VecDeque::from([(root.clone(), String::new())]);
+ let mut visited = HashSet::new();
+ let mut visited_identities = HashSet::new();
+ if let Ok(info) = root
+ .query_info_future(
+ "id::file,id::filesystem",
+ gio::FileQueryInfoFlags::NOFOLLOW_SYMLINKS,
+ glib::Priority::DEFAULT,
+ )
+ .await
+ && let Some(identity) = recursive_file_identity(&info)
+ {
+ visited_identities.insert(identity);
+ }
+ let mut entries = Vec::new();
+ let mut state = RecursiveProgress::default();
+
+ while let Some((directory, relative_directory)) = pending.pop_front() {
+ let directory_uri: String = directory.uri().into();
+ if !visited.insert(directory_uri.clone()) {
+ continue;
+ }
+ if visited.len() > MAX_RECURSIVE_DIRECTORIES {
+ bail!("하위 폴더 수가 안전 제한을 초과합니다 (최대 {MAX_RECURSIVE_DIRECTORIES}개)");
+ }
+ let enumerator = match directory
+ .enumerate_children_future(
+ RECURSIVE_ATTRIBUTES,
+ gio::FileQueryInfoFlags::NOFOLLOW_SYMLINKS,
+ glib::Priority::DEFAULT,
+ )
+ .await
+ {
+ Ok(enumerator) => enumerator,
+ Err(error) if directory.equal(root) => {
+ return Err(error)
+ .with_context(|| format!("폴더에 접근할 수 없습니다: {}", directory.uri()));
+ }
+ Err(_) => {
+ state.skipped += 1;
+ progress(state);
+ continue;
+ }
+ };
+ state.directories += 1;
+ loop {
+ let batch = enumerator
+ .next_files_future(128, glib::Priority::DEFAULT)
+ .await?;
+ if batch.is_empty() {
+ break;
+ }
+ state.scanned += batch.len();
+ if state.scanned > MAX_RECURSIVE_ENTRIES {
+ bail!("하위 항목 수가 안전 제한을 초과합니다 (최대 {MAX_RECURSIVE_ENTRIES}개)");
+ }
+ for info in batch {
+ let child = enumerator.child(&info);
+ if info.is_symlink() || !is_within_root(&child, root) {
+ continue;
+ }
+ let display_name = info.display_name();
+ let relative_name = if relative_directory.is_empty() {
+ display_name.to_string()
+ } else {
+ format!("{relative_directory}/{display_name}")
+ };
+ match info.file_type() {
+ gio::FileType::Directory => {
+ if let Some(identity) = recursive_file_identity(&info)
+ && !visited_identities.insert(identity)
+ {
+ continue;
+ }
+ pending.push_back((child.clone(), relative_name.clone()));
+ entries.push(BrowserEntry {
+ uri: child.uri().into(),
+ name: display_name.into(),
+ list_name: Some(relative_name),
+ kind: EntryKind::Directory,
+ size: None,
+ modified: attribute_time(&info, "time::modified"),
+ created: attribute_time(&info, "time::created"),
+ etag: info
+ .has_attribute("etag::value")
+ .then(|| info.etag())
+ .flatten()
+ .map(Into::into),
+ });
+ }
+ gio::FileType::Regular => {
+ let kind = classify_file(Path::new(display_name.as_str()));
+ if !kind.is_viewable() {
+ continue;
+ }
+ state.viewable += 1;
+ entries.push(BrowserEntry {
+ uri: child.uri().into(),
+ name: display_name.into(),
+ list_name: Some(relative_name),
+ kind,
+ size: info
+ .has_attribute("standard::size")
+ .then(|| info.size())
+ .filter(|size| *size >= 0)
+ .map(|size| size as u64),
+ modified: attribute_time(&info, "time::modified"),
+ created: attribute_time(&info, "time::created"),
+ etag: info
+ .has_attribute("etag::value")
+ .then(|| info.etag())
+ .flatten()
+ .map(Into::into),
+ });
+ }
+ _ => {}
+ }
+ }
+ progress(state);
+ }
+ }
+ Ok((entries, state))
+}
+
pub fn mount_operation(
profile: &LocationProfile,
parent: &impl glib::object::IsA,
@@ -179,6 +359,26 @@ pub fn mount_operation(
operation
}
+pub async fn ensure_mounted(
+ file: &gio::File,
+ profile: &LocationProfile,
+ operation: >k::MountOperation,
+) -> Result<()> {
+ if profile.kind == LocationKind::Local || file.is_native() {
+ return Ok(());
+ }
+ match file
+ .mount_enclosing_volume_future(gio::MountMountFlags::NONE, Some(operation))
+ .await
+ {
+ Ok(()) => Ok(()),
+ Err(error) if error.matches(gio::IOErrorEnum::AlreadyMounted) => Ok(()),
+ Err(error) => {
+ Err(error).with_context(|| format!("원격 위치를 마운트할 수 없습니다: {}", file.uri()))
+ }
+ }
+}
+
async fn enumerate_with_mount_retry(
directory: &gio::File,
operation: >k::MountOperation,
@@ -221,8 +421,16 @@ fn attribute_time(info: &gio::FileInfo, attribute: &str) -> Option Option {
+ let filesystem = info.attribute_string("id::filesystem")?;
+ let file = info.attribute_string("id::file")?;
+ Some(format!("{filesystem}:{file}"))
+}
+
#[cfg(test)]
mod tests {
+ use std::fs;
+
use super::*;
#[test]
@@ -272,4 +480,63 @@ mod tests {
let encoded_input = file_from_user_input(LocationKind::Ftp, encoded.uri().as_str());
assert!(encoded_input.equal(&encoded));
}
+
+ #[test]
+ fn enumeration_allows_large_unique_directories_and_stops_repeated_batches() {
+ let mut enumeration = EnumerationProgress::default();
+ for batch_start in (0..330_001).step_by(128) {
+ enumeration.begin_batch();
+ for index in batch_start..(batch_start + 128).min(330_001) {
+ assert!(enumeration.record(format!("smb://server/share/file-{index}")));
+ }
+ assert!(!enumeration.repeated_batch());
+ }
+ assert_eq!(enumeration.len(), 330_001);
+
+ enumeration.begin_batch();
+ for index in 0..128 {
+ assert!(!enumeration.record(format!("smb://server/share/file-{index}")));
+ }
+ assert!(enumeration.repeated_batch());
+ assert_eq!(enumeration.len(), 330_001);
+ }
+
+ #[test]
+ fn recursively_lists_viewable_files_without_following_symlinks() {
+ let directory = tempfile::tempdir().unwrap();
+ let subdirectory = directory.path().join("2권");
+ fs::create_dir(&subdirectory).unwrap();
+ fs::write(directory.path().join("10.zip"), []).unwrap();
+ fs::write(subdirectory.join("page2.jpg"), []).unwrap();
+ fs::write(subdirectory.join("notes.txt"), []).unwrap();
+ #[cfg(unix)]
+ std::os::unix::fs::symlink(directory.path(), subdirectory.join("loop")).unwrap();
+ let profile = LocationProfile {
+ name: "test".into(),
+ kind: LocationKind::Local,
+ address: directory.path().to_string_lossy().into_owned(),
+ username: String::new(),
+ password: String::new(),
+ domain: String::new(),
+ };
+ let root = gio::File::for_path(directory.path());
+ let (entries, progress) = glib::MainContext::default()
+ .block_on(enumerate_tree_entries(&profile, &root, None, |_| {}))
+ .unwrap();
+
+ assert!(
+ entries.iter().any(|entry| {
+ entry.kind == EntryKind::Directory && entry.display_name() == "2권"
+ })
+ );
+ assert!(entries.iter().any(|entry| {
+ entry.kind == EntryKind::ZipArchive && entry.display_name() == "10.zip"
+ }));
+ assert!(entries.iter().any(|entry| {
+ entry.kind == EntryKind::Image && entry.display_name() == "2권/page2.jpg"
+ }));
+ assert!(!entries.iter().any(|entry| entry.name == "notes.txt"));
+ assert!(!entries.iter().any(|entry| entry.name == "loop"));
+ assert_eq!(progress.skipped, 0);
+ }
}
diff --git a/src/viewer.rs b/src/viewer.rs
index d7ca3b7..eb0ee7c 100644
--- a/src/viewer.rs
+++ b/src/viewer.rs
@@ -1,15 +1,16 @@
-use std::cell::RefCell;
+use std::cell::{Cell, RefCell};
use std::collections::{HashMap, HashSet, VecDeque};
-use std::rc::Rc;
+use std::rc::{Rc, Weak};
use std::sync::mpsc::{self, TryRecvError};
use std::thread;
-use std::time::Duration;
+use std::time::{Duration, Instant};
use gtk::gdk;
use gtk::glib;
use gtk::prelude::*;
-use crate::archive::{ArchivePage, DecodedPage, decode_page, list_pages};
+use crate::archive::{ArchivePage, DecodedPage, decode_image_file, decode_page, list_pages};
+use crate::browser::EntryKind;
use crate::database::Database;
use crate::zip_cache::ArchiveSource;
@@ -17,30 +18,314 @@ const CACHE_LIMIT_BYTES: usize = 256 * 1024 * 1024;
const CACHE_LIMIT_PAGES: usize = 16;
const FAST_CACHE_LIMIT_BYTES: usize = 1024 * 1024 * 1024;
const FAST_CACHE_LIMIT_PAGES: usize = 64;
+const VIDEO_SEEK_STEP_US: i64 = 5_000_000;
+const VIDEO_VOLUME_STEP: f64 = 0.05;
+const IMAGE_ZOOM_STEP: f64 = 0.1;
+const IMAGE_ZOOM_MIN: f64 = 0.1;
+const IMAGE_ZOOM_MAX: f64 = 4.0;
+const IMAGE_PAN_STEP: f64 = 100.0;
+const VIEWER_CONTROLLER_KEY: &str = "comicviewer-viewer-controller";
+const MEDIA_VIEWER_CONTROLLER_KEY: &str = "comicviewer-media-viewer-controller";
+const VIEWER_FILE_SEARCH_KEY: &str = "comicviewer-file-search";
+const VIEWER_FILE_SCROLL_KEY: &str = "comicviewer-file-scroll";
+const VIEWER_VIDEO_LOOP_KEY: &str = "comicviewer-video-loop";
+const PRESERVE_SEEK_CLASS: &str = "viewer-preserve-seek";
+
+fn clear_viewer_controller(window: >k::ApplicationWindow) {
+ unsafe {
+ if let Some(controller) = window.steal_data::>(VIEWER_CONTROLLER_KEY) {
+ controller.detach_window_controllers();
+ }
+ if let Some(controller) =
+ window.steal_data::>(MEDIA_VIEWER_CONTROLLER_KEY)
+ {
+ controller.prepare_for_navigation();
+ }
+ }
+}
+
+fn ensure_viewer_close_handler(window: >k::ApplicationWindow) {
+ if window.has_css_class("viewer-close-handler") {
+ return;
+ }
+ window.add_css_class("viewer-close-handler");
+ window.connect_close_request(|window| {
+ clear_viewer_controller(window);
+ glib::Propagation::Proceed
+ });
+}
+
+pub(crate) fn set_viewer_loading(window: >k::ApplicationWindow, loading: bool) {
+ if !window.has_css_class("viewer-loading-key-handler") {
+ window.add_css_class("viewer-loading-key-handler");
+ let keys = gtk::EventControllerKey::new();
+ keys.set_propagation_phase(gtk::PropagationPhase::Capture);
+ let weak_window = window.downgrade();
+ keys.connect_key_pressed(move |_, key, _, _| {
+ let Some(window) = weak_window.upgrade() else {
+ return glib::Propagation::Proceed;
+ };
+ if !window.has_css_class("viewer-loading") || !window.is_fullscreen() {
+ return glib::Propagation::Proceed;
+ }
+ if key == gdk::Key::Escape
+ || key
+ .to_unicode()
+ .is_some_and(|character| character.eq_ignore_ascii_case(&'f'))
+ {
+ window.unfullscreen();
+ if let Some(titlebar) = window.titlebar() {
+ titlebar.set_visible(true);
+ }
+ return glib::Propagation::Stop;
+ }
+ glib::Propagation::Proceed
+ });
+ window.add_controller(keys);
+ }
+ if loading {
+ window.add_css_class("viewer-loading");
+ } else {
+ window.remove_css_class("viewer-loading");
+ }
+}
+
+pub(crate) fn set_viewer_header(
+ window: >k::ApplicationWindow,
+ header: >k::HeaderBar,
+) -> gtk::Box {
+ let host = window
+ .titlebar()
+ .and_downcast::()
+ .unwrap_or_else(|| {
+ let host = gtk::Box::new(gtk::Orientation::Horizontal, 0);
+ host.set_hexpand(true);
+ window.set_titlebar(Some(&host));
+ host
+ });
+ while let Some(child) = host.first_child() {
+ host.remove(&child);
+ }
+ header.set_hexpand(true);
+ host.append(header);
+ host.set_visible(!window.is_fullscreen());
+ host
+}
pub struct ViewerWindow;
+pub struct SiblingNavigator {
+ navigate: Rc bool>,
+ files: Rc Vec>,
+ actions: Rc,
+ recursive: bool,
+}
+
+type SiblingActionResolver = dyn Fn(&str) -> Option;
+
+#[derive(Clone)]
+pub struct SiblingFile {
+ pub uri: String,
+ pub name: String,
+ pub kind: EntryKind,
+}
+
+#[derive(Clone)]
+pub struct SiblingFileActions {
+ pub favorite: FavoriteControl,
+ pub download: FileDownloadControl,
+}
+
+impl SiblingNavigator {
+ pub fn new(
+ navigate: Rc bool>,
+ files: Rc Vec>,
+ actions: Rc,
+ recursive: bool,
+ ) -> Self {
+ Self {
+ navigate,
+ files,
+ actions,
+ recursive,
+ }
+ }
+
+ fn open_relative(&self, forward: bool, window: gtk::ApplicationWindow) -> bool {
+ (self.navigate)(SiblingTarget::Relative(forward), window)
+ }
+
+ fn open_index(&self, index: usize, window: gtk::ApplicationWindow) -> bool {
+ (self.navigate)(SiblingTarget::Index(index), window)
+ }
+
+ fn open_edge(&self, end: bool, window: gtk::ApplicationWindow) -> bool {
+ (self.navigate)(
+ if end {
+ SiblingTarget::Last
+ } else {
+ SiblingTarget::First
+ },
+ window,
+ )
+ }
+
+ fn files(&self) -> Vec {
+ (self.files)()
+ }
+
+ fn seek_files(&self, current_kind: EntryKind) -> Vec {
+ seek_sibling_files(self.files(), current_kind, self.recursive)
+ }
+
+ fn open_uri(&self, uri: &str, window: gtk::ApplicationWindow) -> bool {
+ let files = self.files();
+ let Some(index) = files.iter().position(|file| file.uri == uri) else {
+ return false;
+ };
+ self.open_index(index, window)
+ }
+
+ fn actions(&self, uri: &str) -> Option {
+ (self.actions)(uri)
+ }
+}
+
+#[derive(Clone, Copy)]
+pub enum SiblingTarget {
+ Relative(bool),
+ Index(usize),
+ First,
+ Last,
+}
+
+impl SiblingTarget {
+ pub fn resolve(self, current: usize, count: usize) -> Option {
+ match self {
+ Self::Relative(forward) => sibling_index(current, count, forward),
+ Self::Index(index) => (index < count && index != current).then_some(index),
+ Self::First => (count > 0 && current > 0).then_some(0),
+ Self::Last => count.checked_sub(1).filter(|last| current < *last),
+ }
+ }
+}
+
+#[derive(Clone)]
+pub struct FavoriteControl {
+ pub active: bool,
+ pub toggle: Rc bool>,
+}
+
+#[derive(Clone)]
+pub struct FileDownloadControl {
+ pub download: Rc,
+}
+
+pub struct ViewModeControl {
+ pub selected: u32,
+ pub change: Rc,
+}
+
+pub struct TwoPageDirectionControl {
+ pub selected: u32,
+ pub change: Rc bool>,
+}
+
+pub struct FileViewerControls {
+ pub sibling_navigator: Option,
+ pub favorite_control: FavoriteControl,
+ pub download_control: FileDownloadControl,
+ pub file_drop_control: FileDropControl,
+ pub reuse_window: Option,
+ pub view_mode_control: Option,
+ pub two_page_direction_control: Option,
+}
+
+#[derive(Clone)]
+pub struct FileDropControl {
+ pub handle: Rc, gtk::Window)>,
+}
+
+pub(crate) fn install_file_drop_target(window: >k::ApplicationWindow, control: FileDropControl) {
+ if window.has_css_class("comicviewer-file-drop-target") {
+ return;
+ }
+ window.add_css_class("comicviewer-file-drop-target");
+ let target = gtk::DropTarget::new(gdk::FileList::static_type(), gdk::DragAction::COPY);
+ let weak_window = window.downgrade();
+ target.connect_drop(move |_, value, _, _| {
+ let Ok(file_list) = value.get::() else {
+ return false;
+ };
+ let Some(window) = weak_window.upgrade() else {
+ return false;
+ };
+ (control.handle)(file_list.files(), window.upcast());
+ true
+ });
+ window.add_controller(target);
+}
+
impl ViewerWindow {
pub fn open(
application: >k::Application,
source: ArchiveSource,
database: Rc,
fast_image_loading: bool,
+ case_insensitive_sort: bool,
+ view_mode_control: ViewModeControl,
+ controls: FileViewerControls,
) {
- let title = source
- .local_path
- .file_name()
- .map(|name| name.to_string_lossy().into_owned())
- .unwrap_or_else(|| "Comicviewer".into());
- let window = gtk::ApplicationWindow::builder()
- .application(application)
- .title(&title)
- .default_width(1100)
- .default_height(850)
- .build();
+ let FileViewerControls {
+ sibling_navigator,
+ favorite_control,
+ download_control,
+ file_drop_control,
+ reuse_window,
+ view_mode_control: _,
+ two_page_direction_control,
+ } = controls;
+ let direction_control = two_page_direction_control
+ .expect("archive viewer requires a two-page direction control");
+ let title_files = sibling_navigator
+ .as_ref()
+ .map(SiblingNavigator::files)
+ .unwrap_or_default();
+ let title = viewer_file_title(&source.display_name, &source.source_uri, &title_files);
+ let file_list_query = reuse_window
+ .as_ref()
+ .map(viewer_file_search_query)
+ .unwrap_or_default();
+ let file_list_scroll = reuse_window
+ .as_ref()
+ .map(viewer_file_scroll_position)
+ .unwrap_or_default();
+ if let Some(window) = reuse_window.as_ref() {
+ clear_viewer_controller(window);
+ }
+ let window = reuse_window.unwrap_or_else(|| {
+ gtk::ApplicationWindow::builder()
+ .application(application)
+ .title(&title)
+ .default_width(1100)
+ .default_height(850)
+ .build()
+ });
+ install_file_drop_target(&window, file_drop_control);
+ ensure_viewer_close_handler(&window);
+ set_viewer_loading(&window, false);
+ window.set_title(Some(&title));
let header = gtk::HeaderBar::new();
- header.set_title_widget(Some(>k::Label::new(Some(&title))));
- window.set_titlebar(Some(&header));
+ header.set_title_widget(Some(&viewer_title_label(&title)));
+ let favorite_button = gtk::Button::with_label(favorite_label(favorite_control.active));
+ let download_button = gtk::Button::with_label("파일 다운로드");
+ let file_list_button = gtk::ToggleButton::with_label("파일 목록");
+ file_list_button.set_sensitive(sibling_navigator.is_some());
+ file_list_button.set_active(window.has_css_class("viewer-file-list-visible"));
+ header.pack_end(&download_button);
+ header.pack_end(&favorite_button);
+ header.pack_end(&file_list_button);
+ let titlebar_host = set_viewer_header(&window, &header);
let root = gtk::Box::new(gtk::Orientation::Vertical, 0);
let toolbar = gtk::Box::new(gtk::Orientation::Horizontal, 6);
@@ -61,7 +346,8 @@ impl ViewerWindow {
let page_label = gtk::Label::new(Some("- / -"));
page_label.set_hexpand(true);
let direction_dropdown = gtk::DropDown::from_strings(&["좌→우", "우→좌"]);
- direction_dropdown.set_selected(1);
+ let direction_selected = direction_control.selected.min(1);
+ direction_dropdown.set_selected(direction_selected);
let mode_dropdown = gtk::DropDown::from_strings(&[
"100%",
"폭 맞춤",
@@ -69,7 +355,7 @@ impl ViewerWindow {
"2페이지",
"이어서 보기",
]);
- mode_dropdown.set_selected(1);
+ mode_dropdown.set_selected(view_mode_control.selected);
toolbar.append(&previous_button);
toolbar.append(&shift_back_button);
toolbar.append(&shift_forward_button);
@@ -79,10 +365,12 @@ impl ViewerWindow {
toolbar.append(&mode_dropdown);
let single_picture = page_picture();
+ let single_box = gtk::Box::new(gtk::Orientation::Horizontal, 0);
+ single_box.append(&single_picture);
let single_scrolled = gtk::ScrolledWindow::builder()
.hexpand(true)
.vexpand(true)
- .child(&single_picture)
+ .child(&single_box)
.build();
let left_picture = page_picture();
let right_picture = page_picture();
@@ -90,6 +378,11 @@ impl ViewerWindow {
spread_box.set_homogeneous(true);
spread_box.append(&left_picture);
spread_box.append(&right_picture);
+ let spread_scrolled = gtk::ScrolledWindow::builder()
+ .hexpand(true)
+ .vexpand(true)
+ .child(&spread_box)
+ .build();
let continuous_box = gtk::Box::new(gtk::Orientation::Vertical, 8);
continuous_box.set_halign(gtk::Align::Fill);
@@ -102,7 +395,7 @@ impl ViewerWindow {
stack.set_hexpand(true);
stack.set_vexpand(true);
stack.add_named(&single_scrolled, Some("single"));
- stack.add_named(&spread_box, Some("spread"));
+ stack.add_named(&spread_scrolled, Some("spread"));
stack.add_named(&continuous_scrolled, Some("continuous"));
let spinner = gtk::Spinner::new();
@@ -119,23 +412,46 @@ impl ViewerWindow {
.margin_start(8)
.margin_end(8)
.build();
+ let page_seek = navigation_scale();
+ let page_seek_row = navigation_scale_row(&page_seek);
+ page_seek.set_sensitive(false);
root.append(&toolbar);
root.append(&overlay);
+ root.append(&page_seek_row);
root.append(&status_label);
- window.set_child(Some(&root));
+ let window_overlay = gtk::Overlay::new();
+ window_overlay.set_child(Some(&root));
+ let (navigation_message, navigation_message_label) = navigation_message();
+ window_overlay.add_overlay(&navigation_message);
+ window_overlay.set_hexpand(true);
+ window_overlay.set_vexpand(true);
+ let file_list = viewer_file_list(&file_list_query);
+ file_list.panel.set_visible(file_list_button.is_active());
+ let viewer_layout = gtk::Box::new(gtk::Orientation::Horizontal, 0);
+ viewer_layout.append(&window_overlay);
+ viewer_layout.append(&file_list.panel);
+ window.set_child(Some(&viewer_layout));
let controller = Rc::new(ViewerController {
window,
+ titlebar_host,
source,
database,
stack,
+ single_scrolled,
+ single_box,
single_picture,
left_picture,
right_picture,
+ spread_box,
+ spread_scrolled,
continuous_box,
continuous_scrolled,
spinner,
page_label,
+ page_seek,
+ page_seek_row,
+ toolbar,
status_label,
previous_button,
next_button,
@@ -144,6 +460,41 @@ impl ViewerWindow {
mode_dropdown,
direction_dropdown,
fast_image_loading,
+ case_insensitive_sort,
+ sibling_navigator,
+ file_list_button,
+ file_list_panel: file_list.panel,
+ file_list_search: file_list.search,
+ file_list_scrolled: file_list.scrolled,
+ file_list: file_list.list,
+ file_list_files: RefCell::new(Vec::new()),
+ file_list_scroll_restore: Cell::new(Some(file_list_scroll)),
+ favorite_button,
+ favorite_toggle: favorite_control.toggle,
+ download_button,
+ file_download: download_control.download,
+ view_mode_change: view_mode_control.change,
+ direction_change: direction_control.change,
+ direction_selected: Cell::new(direction_selected),
+ seek_hide_timer: RefCell::new(None),
+ seek_interacting: Cell::new(false),
+ last_pointer_position: Cell::new(None),
+ key_controller: RefCell::new(None),
+ motion_controller: RefCell::new(None),
+ fullscreen_key_controller: RefCell::new(None),
+ fullscreen_click_controller: RefCell::new(None),
+ fullscreen_ui_hide_timer: RefCell::new(None),
+ fullscreen_ui_visible: Cell::new(false),
+ fullscreen_notify_handler: RefCell::new(None),
+ image_zoom: Cell::new(1.0),
+ navigation_message,
+ navigation_message_label,
+ navigation_message_generation: Rc::new(Cell::new(0)),
+ continuous_programmatic_scroll: Cell::new(false),
+ view_layout_generation: Cell::new(0),
+ single_animation_generation: Rc::new(AnimationState::default()),
+ left_animation_generation: Rc::new(AnimationState::default()),
+ right_animation_generation: Rc::new(AnimationState::default()),
state: RefCell::new(ViewerState {
pages: Vec::new(),
anchor: 0,
@@ -158,6 +509,23 @@ impl ViewerWindow {
}),
});
controller.connect_signals();
+ controller.fullscreen_changed();
+ if controller.window.has_css_class(PRESERVE_SEEK_CLASS) {
+ controller.window.remove_css_class(PRESERVE_SEEK_CLASS);
+ if controller.window.is_fullscreen() {
+ controller.show_fullscreen_ui_temporarily();
+ } else {
+ controller.show_seek_temporarily();
+ }
+ }
+ if controller.file_list_button.is_active() {
+ controller.refresh_file_list();
+ }
+ unsafe {
+ controller
+ .window
+ .set_data(VIEWER_CONTROLLER_KEY, Rc::clone(&controller));
+ }
controller.apply_view_mode();
controller.window.present();
controller.load_archive();
@@ -173,16 +541,55 @@ enum ViewMode {
Continuous,
}
-struct CachedPage {
+#[derive(Clone)]
+struct CachedFrame {
texture: gdk::MemoryTexture,
+ delay: Duration,
+}
+
+struct CachedAnimation {
+ frames: Vec,
+ loop_count: Option,
+}
+
+impl std::ops::Deref for CachedAnimation {
+ type Target = [CachedFrame];
+
+ fn deref(&self) -> &Self::Target {
+ &self.frames
+ }
+}
+
+struct CachedPage {
+ frames: Rc,
cost: usize,
last_used: u64,
}
+#[derive(Default)]
+struct AnimationState {
+ generation: Cell,
+ timer: RefCell>,
+ frames: RefCell>>,
+}
+
+impl AnimationState {
+ fn cancel(&self) -> u64 {
+ if let Some(timer) = self.timer.borrow_mut().take() {
+ timer.remove();
+ }
+ self.frames.borrow_mut().take();
+ let generation = self.generation.get().wrapping_add(1);
+ self.generation.set(generation);
+ generation
+ }
+}
+
struct ContinuousRow {
frame: gtk::AspectFrame,
picture: gtk::Picture,
ratio: f32,
+ animation_generation: Rc,
}
struct ViewerState {
@@ -200,16 +607,24 @@ struct ViewerState {
struct ViewerController {
window: gtk::ApplicationWindow,
+ titlebar_host: gtk::Box,
source: ArchiveSource,
database: Rc,
stack: gtk::Stack,
+ single_scrolled: gtk::ScrolledWindow,
+ single_box: gtk::Box,
single_picture: gtk::Picture,
left_picture: gtk::Picture,
right_picture: gtk::Picture,
+ spread_box: gtk::Box,
+ spread_scrolled: gtk::ScrolledWindow,
continuous_box: gtk::Box,
continuous_scrolled: gtk::ScrolledWindow,
spinner: gtk::Spinner,
page_label: gtk::Label,
+ page_seek: gtk::Scale,
+ page_seek_row: gtk::Box,
+ toolbar: gtk::Box,
status_label: gtk::Label,
previous_button: gtk::Button,
next_button: gtk::Button,
@@ -218,48 +633,281 @@ struct ViewerController {
mode_dropdown: gtk::DropDown,
direction_dropdown: gtk::DropDown,
fast_image_loading: bool,
+ case_insensitive_sort: bool,
+ sibling_navigator: Option,
+ file_list_button: gtk::ToggleButton,
+ file_list_panel: gtk::Box,
+ file_list_search: gtk::SearchEntry,
+ file_list_scrolled: gtk::ScrolledWindow,
+ file_list: gtk::ListBox,
+ file_list_files: RefCell>,
+ file_list_scroll_restore: Cell>,
+ favorite_button: gtk::Button,
+ favorite_toggle: Rc bool>,
+ download_button: gtk::Button,
+ file_download: Rc,
+ view_mode_change: Rc,
+ direction_change: Rc bool>,
+ direction_selected: Cell,
+ seek_hide_timer: RefCell>,
+ seek_interacting: Cell,
+ last_pointer_position: Cell>,
+ key_controller: RefCell>,
+ motion_controller: RefCell>,
+ fullscreen_key_controller: RefCell>,
+ fullscreen_click_controller: RefCell>,
+ fullscreen_ui_hide_timer: RefCell>,
+ fullscreen_ui_visible: Cell,
+ fullscreen_notify_handler: RefCell>,
+ image_zoom: Cell,
+ navigation_message: gtk::Box,
+ navigation_message_label: gtk::Label,
+ navigation_message_generation: Rc>,
+ continuous_programmatic_scroll: Cell,
+ view_layout_generation: Cell,
+ single_animation_generation: Rc,
+ left_animation_generation: Rc,
+ right_animation_generation: Rc,
state: RefCell,
}
impl ViewerController {
fn connect_signals(self: &Rc) {
- let controller = Rc::clone(self);
- self.previous_button
- .connect_clicked(move |_| controller.navigate(false));
- let controller = Rc::clone(self);
- self.next_button
- .connect_clicked(move |_| controller.navigate(true));
- let controller = Rc::clone(self);
- self.shift_back_button
- .connect_clicked(move |_| controller.shift_pairing(-1));
- let controller = Rc::clone(self);
- self.shift_forward_button
- .connect_clicked(move |_| controller.shift_pairing(1));
- let controller = Rc::clone(self);
- self.mode_dropdown
- .connect_selected_notify(move |_| controller.apply_view_mode());
- let controller = Rc::clone(self);
+ let controller = Rc::downgrade(self);
+ self.previous_button.connect_clicked(move |_| {
+ if let Some(controller) = controller.upgrade() {
+ controller.navigate_from_button(false);
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.next_button.connect_clicked(move |_| {
+ if let Some(controller) = controller.upgrade() {
+ controller.navigate_from_button(true);
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.shift_back_button.connect_clicked(move |_| {
+ if let Some(controller) = controller.upgrade() {
+ controller.shift_pairing(-1);
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.shift_forward_button.connect_clicked(move |_| {
+ if let Some(controller) = controller.upgrade() {
+ controller.shift_pairing(1);
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.mode_dropdown.connect_selected_notify(move |dropdown| {
+ if let Some(controller) = controller.upgrade() {
+ (controller.view_mode_change)(dropdown.selected());
+ controller.image_zoom.set(1.0);
+ controller.apply_view_mode();
+ }
+ });
+ let controller = Rc::downgrade(self);
self.direction_dropdown
- .connect_selected_notify(move |_| controller.render());
+ .connect_selected_notify(move |dropdown| {
+ if let Some(controller) = controller.upgrade() {
+ let selected = dropdown.selected().min(1);
+ if (controller.direction_change)(selected) {
+ controller.direction_selected.set(selected);
+ controller.render();
+ } else {
+ dropdown.set_selected(controller.direction_selected.get());
+ }
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.favorite_button.connect_clicked(move |_| {
+ if let Some(controller) = controller.upgrade() {
+ let active = (controller.favorite_toggle)();
+ controller.favorite_button.set_label(favorite_label(active));
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.download_button.connect_clicked(move |_| {
+ if let Some(controller) = controller.upgrade() {
+ (controller.file_download)(
+ controller.window.clone().upcast(),
+ controller.status_label.clone(),
+ );
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.file_list_button.connect_toggled(move |button| {
+ if let Some(controller) = controller.upgrade() {
+ controller.file_list_panel.set_visible(
+ button.is_active()
+ && (!controller.window.is_fullscreen()
+ || controller.fullscreen_ui_visible.get()),
+ );
+ if button.is_active() {
+ controller.window.add_css_class("viewer-file-list-visible");
+ } else {
+ controller
+ .window
+ .remove_css_class("viewer-file-list-visible");
+ }
+ if button.is_active() {
+ controller.refresh_file_list();
+ }
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.file_list.connect_row_activated(move |_, row| {
+ if let Some(controller) = controller.upgrade() {
+ controller.open_file_list_row(row.index());
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.file_list_search.connect_search_changed(move |search| {
+ if let Some(controller) = controller.upgrade() {
+ store_viewer_file_search_query(&controller.window, search.text().as_str());
+ controller.refresh_file_list();
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.file_list_scrolled
+ .vadjustment()
+ .connect_value_changed(move |adjustment| {
+ if let Some(controller) = controller.upgrade()
+ && controller.file_list_scroll_restore.get().is_none()
+ {
+ store_viewer_file_scroll_position(&controller.window, adjustment.value());
+ }
+ });
+ let file_list_typeahead = Rc::new(RefCell::new(TypeaheadBuffer::default()));
+ let file_list_keys = gtk::EventControllerKey::new();
+ let controller = Rc::downgrade(self);
+ file_list_keys.connect_key_pressed(move |_, key, _, modifiers| {
+ let Some(controller) = controller.upgrade() else {
+ return glib::Propagation::Proceed;
+ };
+ file_list_typeahead_select(
+ &controller.file_list,
+ &controller.file_list_files.borrow(),
+ &mut file_list_typeahead.borrow_mut(),
+ key,
+ modifiers,
+ )
+ });
+ self.file_list.add_controller(file_list_keys);
+ let file_list_click = gtk::GestureClick::builder().button(3).build();
+ let controller = Rc::downgrade(self);
+ file_list_click.connect_pressed(move |_, _, x, y| {
+ if let Some(controller) = controller.upgrade() {
+ controller.show_file_list_context_menu(x, y);
+ }
+ });
+ self.file_list.add_controller(file_list_click);
+ let controller = Rc::downgrade(self);
+ self.page_seek.connect_value_changed(move |scale| {
+ let Some(controller) = controller.upgrade() else {
+ return;
+ };
+ let page_count = controller.state.borrow().pages.len();
+ if let Some(index) = page_seek_index(scale.value(), page_count) {
+ controller.seek_page(index);
+ }
+ });
+ let seek_events = gtk::EventControllerLegacy::new();
+ seek_events.set_propagation_phase(gtk::PropagationPhase::Capture);
+ let controller = Rc::downgrade(self);
+ seek_events.connect_event(move |_, event| {
+ if event
+ .downcast_ref::()
+ .is_some_and(|event| event.button() == gdk::BUTTON_PRIMARY)
+ && let Some(controller) = controller.upgrade()
+ {
+ match event.event_type() {
+ gdk::EventType::ButtonPress => controller.begin_seek_interaction(),
+ gdk::EventType::ButtonRelease => controller.end_seek_interaction(),
+ _ => {}
+ }
+ }
+ glib::Propagation::Proceed
+ });
+ self.page_seek.add_controller(seek_events);
let adjustment = self.continuous_scrolled.vadjustment();
- let controller = Rc::clone(self);
- adjustment.connect_value_changed(move |_| controller.continuous_scrolled());
- let controller = Rc::clone(self);
- adjustment.connect_changed(move |_| controller.continuous_scrolled());
- let controller = Rc::clone(self);
+ let controller = Rc::downgrade(self);
+ adjustment.connect_value_changed(move |_| {
+ if let Some(controller) = controller.upgrade() {
+ controller.continuous_scrolled();
+ }
+ });
+ let controller = Rc::downgrade(self);
+ adjustment.connect_changed(move |_| {
+ if let Some(controller) = controller.upgrade() {
+ controller.continuous_scrolled();
+ }
+ });
+ let controller = Rc::downgrade(self);
self.continuous_scrolled
.connect_notify_local(Some("width"), move |_, _| {
- controller.resize_continuous_rows();
+ if let Some(controller) = controller.upgrade() {
+ controller.resize_continuous_rows();
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.single_scrolled
+ .connect_notify_local(Some("width"), move |_, _| {
+ if let Some(controller) = controller.upgrade() {
+ controller.resize_single_picture();
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.single_scrolled
+ .connect_notify_local(Some("height"), move |_, _| {
+ if let Some(controller) = controller.upgrade() {
+ controller.resize_single_picture();
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.single_picture
+ .connect_notify_local(Some("width"), move |_, _| {
+ if let Some(controller) = controller.upgrade() {
+ controller.resize_single_picture();
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.spread_scrolled
+ .connect_notify_local(Some("width"), move |_, _| {
+ if let Some(controller) = controller.upgrade() {
+ controller.resize_spread_pictures();
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.spread_scrolled
+ .connect_notify_local(Some("height"), move |_, _| {
+ if let Some(controller) = controller.upgrade() {
+ controller.resize_spread_pictures();
+ }
});
let scroll_controller = gtk::EventControllerScroll::new(
gtk::EventControllerScrollFlags::VERTICAL | gtk::EventControllerScrollFlags::DISCRETE,
);
scroll_controller.set_propagation_phase(gtk::PropagationPhase::Capture);
- let controller = Rc::clone(self);
- scroll_controller.connect_scroll(move |_, _, delta_y| {
- if controller.view_mode() == ViewMode::Continuous || delta_y == 0.0 {
+ let controller = Rc::downgrade(self);
+ scroll_controller.connect_scroll(move |scroll, _, delta_y| {
+ let Some(controller) = controller.upgrade() else {
+ return glib::Propagation::Proceed;
+ };
+ if scroll
+ .current_event_state()
+ .contains(gdk::ModifierType::CONTROL_MASK)
+ && delta_y != 0.0
+ {
+ controller.adjust_image_zoom(delta_y < 0.0);
+ return glib::Propagation::Stop;
+ }
+ if matches!(
+ controller.view_mode(),
+ ViewMode::ActualSize | ViewMode::FitWidth | ViewMode::Continuous
+ ) || delta_y == 0.0
+ {
return glib::Propagation::Proceed;
}
controller.navigate(delta_y > 0.0);
@@ -267,31 +915,373 @@ impl ViewerController {
});
self.stack.add_controller(scroll_controller);
- let key_controller = gtk::EventControllerKey::new();
- let controller = Rc::clone(self);
- key_controller.connect_key_pressed(move |_, key, _, _| match key {
- gdk::Key::Left | gdk::Key::Page_Up => {
- controller.navigate(false);
- glib::Propagation::Stop
- }
- gdk::Key::Right | gdk::Key::Page_Down | gdk::Key::space => {
- controller.navigate(true);
- glib::Propagation::Stop
- }
- _ if key
- .to_unicode()
- .is_some_and(|character| character.eq_ignore_ascii_case(&'f')) =>
+ let fullscreen_click = gtk::EventControllerLegacy::new();
+ fullscreen_click.set_propagation_phase(gtk::PropagationPhase::Capture);
+ let controller = Rc::downgrade(self);
+ fullscreen_click.connect_event(move |_, event| {
+ if event.downcast_ref::().is_some()
+ && event.event_type() == gdk::EventType::ButtonPress
+ && let Some(controller) = controller.upgrade()
{
- controller.toggle_fullscreen();
- glib::Propagation::Stop
+ controller.controls_clicked();
+ }
+ glib::Propagation::Proceed
+ });
+ self.window.add_controller(fullscreen_click.clone());
+ self.fullscreen_click_controller
+ .replace(Some(fullscreen_click));
+
+ let motion_controller = gtk::EventControllerMotion::new();
+ motion_controller.set_propagation_phase(gtk::PropagationPhase::Capture);
+ let controller = Rc::downgrade(self);
+ motion_controller.connect_motion(move |_, x, y| {
+ if let Some(controller) = controller.upgrade() {
+ controller.pointer_moved(x, y);
+ }
+ });
+ self.window.add_controller(motion_controller.clone());
+ self.motion_controller.replace(Some(motion_controller));
+
+ let fullscreen_keys = gtk::EventControllerKey::new();
+ fullscreen_keys.set_propagation_phase(gtk::PropagationPhase::Capture);
+ let controller = Rc::downgrade(self);
+ fullscreen_keys.connect_key_pressed(move |_, key, _, _| {
+ if let Some(controller) = controller.upgrade()
+ && !widget_contains_focus(&controller.file_list_search, &controller.window)
+ && controller.window.is_fullscreen()
+ && fullscreen_direction_key(key)
+ {
+ controller.hide_fullscreen_ui_now();
+ }
+ glib::Propagation::Proceed
+ });
+ self.window.add_controller(fullscreen_keys.clone());
+ self.fullscreen_key_controller
+ .replace(Some(fullscreen_keys));
+
+ let key_controller = gtk::EventControllerKey::new();
+ let controller = Rc::downgrade(self);
+ key_controller.connect_key_pressed(move |_, key, _, modifiers| {
+ let Some(controller) = controller.upgrade() else {
+ return glib::Propagation::Proceed;
+ };
+ if widget_contains_focus(&controller.file_list_search, &controller.window) {
+ return glib::Propagation::Proceed;
+ }
+ if !controller.window.is_fullscreen() {
+ controller.hide_seek();
+ }
+ match key {
+ gdk::Key::Home => {
+ controller.seek_edge(false);
+ glib::Propagation::Stop
+ }
+ gdk::Key::End => {
+ controller.seek_edge(true);
+ glib::Propagation::Stop
+ }
+ gdk::Key::Up | gdk::Key::KP_Up if controller.pan_image(false, false) => {
+ glib::Propagation::Stop
+ }
+ gdk::Key::Down | gdk::Key::KP_Down if controller.pan_image(false, true) => {
+ glib::Propagation::Stop
+ }
+ gdk::Key::Left | gdk::Key::KP_Left if controller.pan_image(true, false) => {
+ glib::Propagation::Stop
+ }
+ gdk::Key::Right | gdk::Key::KP_Right if controller.pan_image(true, true) => {
+ glib::Propagation::Stop
+ }
+ gdk::Key::Left | gdk::Key::KP_Left | gdk::Key::Page_Up => {
+ controller.navigate(false);
+ glib::Propagation::Stop
+ }
+ gdk::Key::Right | gdk::Key::KP_Right | gdk::Key::Page_Down | gdk::Key::space => {
+ controller.navigate(true);
+ glib::Propagation::Stop
+ }
+ _ if key.to_unicode() == Some('[') => {
+ controller.open_sibling(false);
+ glib::Propagation::Stop
+ }
+ _ if key.to_unicode() == Some(']') => {
+ controller.open_sibling(true);
+ glib::Propagation::Stop
+ }
+ gdk::Key::plus | gdk::Key::equal | gdk::Key::KP_Add => {
+ controller.adjust_image_zoom(true);
+ glib::Propagation::Stop
+ }
+ gdk::Key::minus | gdk::Key::KP_Subtract => {
+ controller.adjust_image_zoom(false);
+ glib::Propagation::Stop
+ }
+ gdk::Key::_1 | gdk::Key::KP_1 => {
+ controller.select_view_mode(1);
+ glib::Propagation::Stop
+ }
+ gdk::Key::_2 | gdk::Key::KP_2 => {
+ controller.select_view_mode(2);
+ glib::Propagation::Stop
+ }
+ gdk::Key::_3 | gdk::Key::KP_3 => {
+ controller.select_view_mode(3);
+ glib::Propagation::Stop
+ }
+ gdk::Key::_4 | gdk::Key::KP_4 => {
+ controller.select_view_mode(0);
+ glib::Propagation::Stop
+ }
+ _ if !shortcut_modifiers_blocked(modifiers)
+ && key
+ .to_unicode()
+ .is_some_and(|character| character.eq_ignore_ascii_case(&'l')) =>
+ {
+ controller.toggle_file_list();
+ glib::Propagation::Stop
+ }
+ _ if key
+ .to_unicode()
+ .is_some_and(|character| character.eq_ignore_ascii_case(&'f')) =>
+ {
+ controller.toggle_fullscreen();
+ glib::Propagation::Stop
+ }
+ gdk::Key::Escape if controller.window.is_fullscreen() => {
+ controller.window.unfullscreen();
+ glib::Propagation::Stop
+ }
+ _ => glib::Propagation::Proceed,
+ }
+ });
+ self.window.add_controller(key_controller.clone());
+ self.key_controller.replace(Some(key_controller));
+ let controller = Rc::downgrade(self);
+ let handler = self
+ .window
+ .connect_notify_local(Some("fullscreened"), move |_, _| {
+ if let Some(controller) = controller.upgrade() {
+ controller.fullscreen_changed();
+ }
+ });
+ self.fullscreen_notify_handler.replace(Some(handler));
+ }
+
+ fn open_sibling(&self, forward: bool) {
+ if let Some(navigate) = &self.sibling_navigator
+ && navigate.open_relative(forward, self.window.clone())
+ {
+ self.detach_window_controllers();
+ } else {
+ self.show_navigation_error(forward);
+ }
+ }
+
+ fn toggle_file_list(&self) {
+ if !self.file_list_button.is_sensitive() {
+ return;
+ }
+ let active = !self.file_list_button.is_active();
+ self.file_list_button.set_active(active);
+ if self.window.is_fullscreen() {
+ self.file_list_panel.set_visible(active);
+ }
+ }
+
+ fn refresh_file_list(&self) {
+ while let Some(child) = self.file_list.first_child() {
+ self.file_list.remove(&child);
+ }
+ let files = self
+ .sibling_navigator
+ .as_ref()
+ .map(SiblingNavigator::files)
+ .unwrap_or_default();
+ let files = filter_sibling_files(files, self.file_list_search.text().as_str());
+ let current = files
+ .iter()
+ .position(|file| file.uri == self.source.source_uri);
+ for file in &files {
+ self.file_list.append(&viewer_file_row(file));
+ }
+ *self.file_list_files.borrow_mut() = files;
+ if let Some(row) = current.and_then(|index| self.file_list.row_at_index(index as i32)) {
+ self.file_list.select_row(Some(&row));
+ }
+ restore_pending_viewer_file_scroll(
+ &self.file_list_panel,
+ &self.file_list_scrolled,
+ &self.file_list_scroll_restore,
+ );
+ }
+
+ fn open_file_list_row(&self, index: i32) {
+ let Some(uri) = self
+ .file_list_files
+ .borrow()
+ .get(index as usize)
+ .map(|file| file.uri.clone())
+ else {
+ return;
+ };
+ if uri == self.source.source_uri {
+ return;
+ }
+ if let Some(navigator) = &self.sibling_navigator
+ && navigator.open_uri(&uri, self.window.clone())
+ {
+ self.detach_window_controllers();
+ }
+ }
+
+ fn show_file_list_context_menu(&self, x: f64, y: f64) {
+ let Some((row, file)) = selected_viewer_file(&self.file_list, &self.file_list_files, x, y)
+ else {
+ return;
+ };
+ self.file_list.select_row(Some(&row));
+ let Some(actions) = self
+ .sibling_navigator
+ .as_ref()
+ .and_then(|navigator| navigator.actions(&file.uri))
+ else {
+ return;
+ };
+ show_viewer_file_context_menu(
+ &row,
+ &file,
+ actions,
+ &self.source.source_uri,
+ &self.favorite_button,
+ &self.window,
+ &self.status_label,
+ );
+ }
+
+ fn show_navigation_error(&self, forward: bool) {
+ self.navigation_message_label
+ .set_text(navigation_error_message(forward));
+ self.navigation_message.set_visible(true);
+ let message = self.navigation_message.clone();
+ let generation = self.navigation_message_generation.get().wrapping_add(1);
+ self.navigation_message_generation.set(generation);
+ let current_generation = Rc::clone(&self.navigation_message_generation);
+ glib::timeout_add_local_once(Duration::from_secs(2), move || {
+ if current_generation.get() == generation {
+ message.set_visible(false);
+ }
+ });
+ }
+
+ fn detach_window_controllers(&self) {
+ self.stop_animations();
+ if let Some(timer) = self.seek_hide_timer.borrow_mut().take() {
+ timer.remove();
+ }
+ self.cancel_fullscreen_ui_timer();
+ if let Some(handler) = self.fullscreen_notify_handler.borrow_mut().take() {
+ self.window.disconnect(handler);
+ }
+ if let Some(controller) = self.key_controller.borrow_mut().take() {
+ self.window.remove_controller(&controller);
+ }
+ if let Some(controller) = self.motion_controller.borrow_mut().take() {
+ self.window.remove_controller(&controller);
+ }
+ if let Some(controller) = self.fullscreen_key_controller.borrow_mut().take() {
+ self.window.remove_controller(&controller);
+ }
+ if let Some(controller) = self.fullscreen_click_controller.borrow_mut().take() {
+ self.window.remove_controller(&controller);
+ }
+ }
+
+ fn stop_animations(&self) {
+ self.single_animation_generation.cancel();
+ self.left_animation_generation.cancel();
+ self.right_animation_generation.cancel();
+ for row in &self.state.borrow().continuous_rows {
+ row.animation_generation.cancel();
+ }
+ }
+
+ fn show_seek_temporarily(self: &Rc) {
+ if let Some(timer) = self.seek_hide_timer.borrow_mut().take() {
+ timer.remove();
+ }
+ self.set_seek_visible(true);
+ let controller = Rc::downgrade(self);
+ let timer = glib::timeout_add_local_once(Duration::from_secs(5), move || {
+ if let Some(controller) = controller.upgrade() {
+ controller.seek_hide_timer.borrow_mut().take();
+ if !controller.seek_interacting.get() {
+ controller.set_seek_visible(false);
+ }
+ }
+ });
+ self.seek_hide_timer.replace(Some(timer));
+ }
+
+ fn begin_seek_interaction(self: &Rc) {
+ self.seek_interacting.set(true);
+ if let Some(timer) = self.seek_hide_timer.borrow_mut().take() {
+ timer.remove();
+ }
+ self.cancel_fullscreen_ui_timer();
+ if self.window.is_fullscreen() {
+ self.set_fullscreen_ui_visible(true);
+ } else {
+ self.set_seek_visible(true);
+ }
+ }
+
+ fn end_seek_interaction(self: &Rc) {
+ self.seek_interacting.set(false);
+ if self.window.is_fullscreen() {
+ self.show_fullscreen_ui_temporarily();
+ } else {
+ self.show_seek_temporarily();
+ }
+ }
+
+ fn pointer_moved(self: &Rc, x: f64, y: f64) {
+ if self.last_pointer_position.get() == Some((x, y)) {
+ return;
+ }
+ self.last_pointer_position.set(Some((x, y)));
+ }
+
+ fn controls_clicked(self: &Rc) {
+ if self.window.is_fullscreen() {
+ self.show_fullscreen_ui_temporarily();
+ } else {
+ self.show_seek_temporarily();
+ }
+ }
+
+ fn hide_seek(self: &Rc) {
+ if let Some(timer) = self.seek_hide_timer.borrow_mut().take() {
+ timer.remove();
+ }
+ if !self.seek_interacting.get() {
+ self.set_seek_visible(false);
+ }
+ }
+
+ fn set_seek_visible(self: &Rc, visible: bool) {
+ if self.page_seek_row.is_visible() == visible {
+ return;
+ }
+ self.page_seek_row.set_visible(visible);
+ self.window.queue_allocate();
+ let controller = Rc::downgrade(self);
+ glib::idle_add_local_once(move || {
+ if let Some(controller) = controller.upgrade() {
+ controller.stack.queue_allocate();
+ controller.resize_continuous_rows();
+ controller.render();
}
- gdk::Key::Escape if controller.window.is_fullscreen() => {
- controller.window.unfullscreen();
- glib::Propagation::Stop
- }
- _ => glib::Propagation::Proceed,
});
- self.window.add_controller(key_controller);
}
fn toggle_fullscreen(&self) {
@@ -302,12 +1292,88 @@ impl ViewerController {
}
}
+ fn fullscreen_changed(self: &Rc) {
+ self.cancel_fullscreen_ui_timer();
+ self.hide_seek();
+ if self.window.is_fullscreen() {
+ self.set_fullscreen_ui_visible(false);
+ } else {
+ self.fullscreen_ui_visible.set(true);
+ self.titlebar_host.set_visible(true);
+ self.toolbar.set_visible(true);
+ self.status_label.set_visible(true);
+ self.file_list_panel
+ .set_visible(self.file_list_button.is_active());
+ restore_pending_viewer_file_scroll(
+ &self.file_list_panel,
+ &self.file_list_scrolled,
+ &self.file_list_scroll_restore,
+ );
+ }
+ }
+
+ fn show_fullscreen_ui_temporarily(self: &Rc) {
+ if !self.window.is_fullscreen() {
+ return;
+ }
+ self.cancel_fullscreen_ui_timer();
+ self.set_fullscreen_ui_visible(true);
+ let controller = Rc::downgrade(self);
+ let timer = glib::timeout_add_local_once(Duration::from_secs(5), move || {
+ if let Some(controller) = controller.upgrade() {
+ controller.fullscreen_ui_hide_timer.borrow_mut().take();
+ controller.set_fullscreen_ui_visible(false);
+ }
+ });
+ self.fullscreen_ui_hide_timer.replace(Some(timer));
+ }
+
+ fn hide_fullscreen_ui_now(self: &Rc) {
+ if self.window.is_fullscreen() && !self.seek_interacting.get() {
+ self.cancel_fullscreen_ui_timer();
+ self.set_fullscreen_ui_visible(false);
+ }
+ }
+
+ fn cancel_fullscreen_ui_timer(&self) {
+ if let Some(timer) = self.fullscreen_ui_hide_timer.borrow_mut().take() {
+ timer.remove();
+ }
+ }
+
+ fn set_fullscreen_ui_visible(self: &Rc, visible: bool) {
+ self.fullscreen_ui_visible.set(visible);
+ self.titlebar_host.set_visible(visible);
+ self.toolbar.set_visible(visible);
+ self.page_seek_row.set_visible(visible);
+ self.status_label.set_visible(visible);
+ self.file_list_panel
+ .set_visible(visible && self.file_list_button.is_active());
+ restore_pending_viewer_file_scroll(
+ &self.file_list_panel,
+ &self.file_list_scrolled,
+ &self.file_list_scroll_restore,
+ );
+ self.window.queue_allocate();
+ let controller = Rc::downgrade(self);
+ glib::idle_add_local_once(move || {
+ if let Some(controller) = controller.upgrade() {
+ controller.stack.queue_allocate();
+ controller.resize_continuous_rows();
+ controller.render();
+ }
+ });
+ }
+
fn load_archive(self: &Rc) {
self.spinner.start();
let path = self.source.local_path.clone();
+ let case_insensitive_sort = self.case_insensitive_sort;
let (sender, receiver) = mpsc::channel();
thread::spawn(move || {
- let _ = sender.send(list_pages(&path).map_err(|error| format!("{error:#}")));
+ let _ = sender.send(
+ list_pages(&path, case_insensitive_sort).map_err(|error| format!("{error:#}")),
+ );
});
let controller = Rc::downgrade(self);
glib::timeout_add_local(Duration::from_millis(20), move || {
@@ -332,6 +1398,7 @@ impl ViewerController {
.set_text("지원하는 이미지가 ZIP 파일에 없습니다.");
}
Ok(pages) => {
+ let page_count = pages.len();
let saved = self
.database
.load_progress(&self.source.source_uri)
@@ -343,6 +1410,9 @@ impl ViewerController {
state.pages = pages;
state.anchor = saved;
drop(state);
+ self.page_seek
+ .set_range(0.0, navigation_scale_upper(page_count));
+ self.page_seek.set_sensitive(page_count > 1);
self.build_continuous_rows();
self.render();
}
@@ -377,6 +1447,7 @@ impl ViewerController {
frame,
picture,
ratio: default_ratio,
+ animation_generation: Rc::new(AnimationState::default()),
});
}
let mut state = self.state.borrow_mut();
@@ -407,22 +1478,133 @@ impl ViewerController {
ViewMode::Continuous => self.stack.set_visible_child_name("continuous"),
_ => self.stack.set_visible_child_name("single"),
}
- if mode == ViewMode::Continuous {
- self.single_picture.set_paintable(gdk::Paintable::NONE);
- self.left_picture.set_paintable(gdk::Paintable::NONE);
- self.right_picture.set_paintable(gdk::Paintable::NONE);
- self.schedule_scroll_to_anchor();
- } else {
- self.clear_continuous_paintables();
+ match mode {
+ ViewMode::Continuous => {
+ set_picture_animation(
+ &self.single_picture,
+ None,
+ &self.single_animation_generation,
+ );
+ set_picture_animation(&self.left_picture, None, &self.left_animation_generation);
+ set_picture_animation(&self.right_picture, None, &self.right_animation_generation);
+ }
+ ViewMode::TwoPage => {
+ set_picture_animation(
+ &self.single_picture,
+ None,
+ &self.single_animation_generation,
+ );
+ self.clear_continuous_paintables();
+ }
+ _ => {
+ set_picture_animation(&self.left_picture, None, &self.left_animation_generation);
+ set_picture_animation(&self.right_picture, None, &self.right_animation_generation);
+ self.clear_continuous_paintables();
+ }
}
let actual = mode == ViewMode::ActualSize;
+ self.single_box.set_hexpand(!actual);
+ self.single_box.set_vexpand(mode == ViewMode::FitHeight);
+ self.single_box.set_halign(match mode {
+ ViewMode::ActualSize => gtk::Align::Start,
+ ViewMode::FitHeight => gtk::Align::Center,
+ _ => gtk::Align::Fill,
+ });
+ self.single_box.set_valign(if actual {
+ gtk::Align::Start
+ } else {
+ gtk::Align::Fill
+ });
self.single_picture.set_can_shrink(!actual);
self.single_picture.set_hexpand(mode == ViewMode::FitWidth);
self.single_picture.set_vexpand(mode == ViewMode::FitHeight);
+ if matches!(mode, ViewMode::ActualSize | ViewMode::FitWidth) {
+ self.single_picture.set_content_fit(gtk::ContentFit::Fill);
+ self.single_picture.set_valign(gtk::Align::Start);
+ self.single_picture
+ .set_halign(if mode == ViewMode::FitWidth {
+ gtk::Align::Fill
+ } else {
+ gtk::Align::Start
+ });
+ } else {
+ self.single_picture
+ .set_content_fit(gtk::ContentFit::Contain);
+ self.single_picture.set_valign(gtk::Align::Fill);
+ self.single_picture
+ .set_halign(if mode == ViewMode::FitHeight {
+ gtk::Align::Center
+ } else {
+ gtk::Align::Fill
+ });
+ self.single_picture.set_size_request(-1, -1);
+ }
self.render();
+ self.schedule_view_mode_refresh();
}
- fn navigate(self: &Rc, forward: bool) {
+ fn adjust_image_zoom(self: &Rc, zoom_in: bool) {
+ let zoom = next_image_zoom(self.image_zoom.get(), zoom_in);
+ if (zoom - self.image_zoom.get()).abs() < f64::EPSILON {
+ return;
+ }
+ self.image_zoom.set(zoom);
+ if (zoom - 1.0).abs() < f64::EPSILON {
+ self.apply_view_mode();
+ return;
+ }
+ match self.view_mode() {
+ ViewMode::TwoPage => self.resize_spread_pictures(),
+ ViewMode::Continuous => {
+ self.resize_continuous_rows();
+ self.continuous_scrolled();
+ }
+ _ => self.resize_single_picture(),
+ }
+ self.stack.queue_allocate();
+ }
+
+ fn select_view_mode(self: &Rc, index: u32) {
+ if self.mode_dropdown.selected() != index {
+ self.mode_dropdown.set_selected(index);
+ } else {
+ self.image_zoom.set(1.0);
+ self.apply_view_mode();
+ }
+ }
+
+ fn schedule_view_mode_refresh(self: &Rc) {
+ let generation = self.view_layout_generation.get().wrapping_add(1);
+ self.view_layout_generation.set(generation);
+ self.stack.queue_allocate();
+ self.window.queue_allocate();
+ let controller = Rc::downgrade(self);
+ glib::idle_add_local_once(move || {
+ let Some(controller) = controller.upgrade() else {
+ return;
+ };
+ if controller.view_layout_generation.get() != generation {
+ return;
+ }
+ match controller.view_mode() {
+ ViewMode::FitWidth => controller.resize_single_picture(),
+ ViewMode::Continuous => controller.resize_continuous_rows(),
+ _ => {}
+ }
+ controller.render();
+ if controller.view_mode() == ViewMode::Continuous {
+ controller.schedule_scroll_to_anchor();
+ }
+ });
+ }
+
+ fn navigate_from_button(self: &Rc, forward: bool) {
+ if self.navigate(forward) && (self.image_zoom.replace(1.0) - 1.0).abs() >= f64::EPSILON {
+ self.apply_view_mode();
+ }
+ }
+
+ fn navigate(self: &Rc, forward: bool) -> bool {
let step = if self.view_mode() == ViewMode::TwoPage {
2
} else {
@@ -430,7 +1612,7 @@ impl ViewerController {
};
let mut state = self.state.borrow_mut();
if state.pages.is_empty() {
- return;
+ return false;
}
let next = if forward {
state.anchor.saturating_add(step).min(state.pages.len() - 1)
@@ -438,14 +1620,38 @@ impl ViewerController {
state.anchor.saturating_sub(step)
};
if next == state.anchor {
- return;
+ return false;
}
state.anchor = next;
drop(state);
+ self.reset_single_scroll();
self.render();
if self.view_mode() == ViewMode::Continuous {
self.schedule_scroll_to_anchor();
}
+ true
+ }
+
+ fn seek_edge(self: &Rc, end: bool) {
+ let count = self.state.borrow().pages.len();
+ if count == 0 {
+ return;
+ }
+ self.seek_page(if end { count - 1 } else { 0 });
+ }
+
+ fn pan_image(&self, horizontal: bool, forward: bool) -> bool {
+ let scrolled = match self.view_mode() {
+ ViewMode::TwoPage => &self.spread_scrolled,
+ ViewMode::Continuous => &self.continuous_scrolled,
+ _ => &self.single_scrolled,
+ };
+ let adjustment = if horizontal {
+ scrolled.hadjustment()
+ } else {
+ scrolled.vadjustment()
+ };
+ pan_adjustment(&adjustment, forward)
}
fn shift_pairing(self: &Rc, offset: isize) {
@@ -461,6 +1667,24 @@ impl ViewerController {
self.render();
}
+ fn seek_page(self: &Rc, index: usize) {
+ let mut state = self.state.borrow_mut();
+ if state.pages.is_empty() {
+ return;
+ }
+ let index = index.min(state.pages.len() - 1);
+ if index == state.anchor {
+ return;
+ }
+ state.anchor = index;
+ drop(state);
+ self.reset_single_scroll();
+ self.render();
+ if self.view_mode() == ViewMode::Continuous {
+ self.schedule_scroll_to_anchor();
+ }
+ }
+
fn render(self: &Rc) {
let visible = self.visible_indices();
if visible.is_empty() {
@@ -573,21 +1797,13 @@ impl ViewerController {
Ok(page) => {
let ratio = page.width as f32 / page.height as f32;
decoded_ratio = Some(ratio);
- let cost = page.rgba.len();
- let bytes = glib::Bytes::from_owned(page.rgba);
- let texture = gdk::MemoryTexture::new(
- page.width as i32,
- page.height as i32,
- gdk::MemoryFormat::R8g8b8a8,
- &bytes,
- page.width as usize * 4,
- );
+ let (frames, cost) = texture_frames(page);
state.access_clock = state.access_clock.wrapping_add(1);
let last_used = state.access_clock;
state.cache.insert(
index,
CachedPage {
- texture,
+ frames,
cost,
last_used,
},
@@ -608,11 +1824,13 @@ impl ViewerController {
};
if let Some(frame) = frame {
frame.set_ratio(ratio);
- frame.set_size_request(-1, row_height(self.continuous_content_width(), ratio));
+ self.resize_continuous_rows();
}
}
self.evict_cache();
- self.render_loaded_pages();
+ if self.visible_indices().contains(&index) {
+ self.render_loaded_pages();
+ }
self.update_spinner();
self.pump_requests();
}
@@ -629,33 +1847,159 @@ impl ViewerController {
fn render_single(&self, index: usize) {
let state = self.state.borrow();
- self.single_picture
- .set_paintable(state.cache.get(&index).map(|page| &page.texture));
+ let frames = state.cache.get(&index).map(|page| Rc::clone(&page.frames));
self.status_label.set_text(&state.pages[index].name);
+ drop(state);
+ set_picture_animation(
+ &self.single_picture,
+ frames,
+ &self.single_animation_generation,
+ );
+ self.resize_single_picture();
+ }
+
+ fn resize_single_picture(&self) {
+ let dimensions = {
+ let state = self.state.borrow();
+ state
+ .cache
+ .get(&state.anchor)
+ .and_then(|page| page.frames.first())
+ .map(|frame| (frame.texture.width(), frame.texture.height()))
+ };
+ if let Some((texture_width, texture_height)) = dimensions {
+ let zoom = self.image_zoom.get();
+ if (zoom - 1.0).abs() >= f64::EPSILON {
+ let (width, height) = zoomed_picture_request(
+ self.view_mode(),
+ self.single_scrolled.width().max(1),
+ self.single_scrolled.height().max(1),
+ texture_width,
+ texture_height,
+ zoom,
+ );
+ self.single_box.set_hexpand(true);
+ self.single_box.set_vexpand(true);
+ self.single_box.set_halign(gtk::Align::Fill);
+ self.single_box.set_valign(gtk::Align::Fill);
+ self.single_picture.set_can_shrink(false);
+ self.single_picture.set_hexpand(false);
+ self.single_picture.set_vexpand(false);
+ self.single_picture.set_content_fit(gtk::ContentFit::Fill);
+ self.single_picture.set_halign(gtk::Align::Center);
+ self.single_picture.set_valign(gtk::Align::Center);
+ self.single_picture.set_size_request(width, height);
+ } else if let Some((width, height)) = single_picture_request(
+ self.view_mode(),
+ self.stack.width().max(1),
+ texture_width,
+ texture_height,
+ ) {
+ self.single_picture.set_size_request(width, height);
+ }
+ }
+ }
+
+ fn resize_spread_pictures(&self) {
+ let zoom = self.image_zoom.get();
+ if (zoom - 1.0).abs() < f64::EPSILON {
+ self.spread_box.set_homogeneous(true);
+ self.spread_box.set_halign(gtk::Align::Fill);
+ self.spread_box.set_valign(gtk::Align::Fill);
+ for picture in [&self.left_picture, &self.right_picture] {
+ picture.set_can_shrink(true);
+ picture.set_hexpand(true);
+ picture.set_vexpand(true);
+ picture.set_content_fit(gtk::ContentFit::Contain);
+ picture.set_size_request(-1, -1);
+ }
+ return;
+ }
+ let visible = self.visible_indices();
+ let state = self.state.borrow();
+ let page_dimensions = |position: usize| {
+ visible.get(position).and_then(|index| {
+ state
+ .cache
+ .get(index)
+ .and_then(|page| page.frames.first())
+ .map(|frame| (frame.texture.width(), frame.texture.height()))
+ })
+ };
+ let first = page_dimensions(0);
+ let second = page_dimensions(1);
+ let dimensions = if self.direction_dropdown.selected() == 1 {
+ [second, first]
+ } else {
+ [first, second]
+ };
+ drop(state);
+ let count = visible.len().max(1) as i32;
+ let viewport_width = (self.spread_scrolled.width().max(1) - 8) / count;
+ let viewport_height = self.spread_scrolled.height().max(1);
+ self.spread_box.set_homogeneous(false);
+ self.spread_box.set_halign(gtk::Align::Center);
+ self.spread_box.set_valign(gtk::Align::Center);
+ for (picture, dimensions) in [&self.left_picture, &self.right_picture]
+ .into_iter()
+ .zip(dimensions)
+ {
+ let Some((texture_width, texture_height)) = dimensions else {
+ picture.set_size_request(1, 1);
+ continue;
+ };
+ let (width, height) = zoomed_picture_request(
+ ViewMode::FitHeight,
+ viewport_width,
+ viewport_height,
+ texture_width,
+ texture_height,
+ zoom,
+ );
+ picture.set_can_shrink(false);
+ picture.set_hexpand(false);
+ picture.set_vexpand(false);
+ picture.set_content_fit(gtk::ContentFit::Fill);
+ picture.set_size_request(width, height);
+ }
+ }
+
+ fn reset_single_scroll(&self) {
+ if matches!(self.view_mode(), ViewMode::ActualSize | ViewMode::FitWidth) {
+ let adjustment = self.single_scrolled.vadjustment();
+ adjustment.set_value(adjustment.lower());
+ }
}
fn render_spread(&self, indices: &[usize]) {
let state = self.state.borrow();
- let first = indices.first().and_then(|index| state.cache.get(index));
- let second = indices.get(1).and_then(|index| state.cache.get(index));
+ let first = indices
+ .first()
+ .and_then(|index| state.cache.get(index))
+ .map(|page| Rc::clone(&page.frames));
+ let second = indices
+ .get(1)
+ .and_then(|index| state.cache.get(index))
+ .map(|page| Rc::clone(&page.frames));
+ let status = indices
+ .iter()
+ .map(|index| state.pages[*index].name.as_str())
+ .collect::>()
+ .join(" · ");
+ drop(state);
if self.direction_dropdown.selected() == 1 {
- self.left_picture
- .set_paintable(second.map(|page| &page.texture));
- self.right_picture
- .set_paintable(first.map(|page| &page.texture));
+ set_picture_animation(&self.left_picture, second, &self.left_animation_generation);
+ set_picture_animation(&self.right_picture, first, &self.right_animation_generation);
} else {
- self.left_picture
- .set_paintable(first.map(|page| &page.texture));
- self.right_picture
- .set_paintable(second.map(|page| &page.texture));
+ set_picture_animation(&self.left_picture, first, &self.left_animation_generation);
+ set_picture_animation(
+ &self.right_picture,
+ second,
+ &self.right_animation_generation,
+ );
}
- self.status_label.set_text(
- &indices
- .iter()
- .map(|index| state.pages[*index].name.as_str())
- .collect::>()
- .join(" · "),
- );
+ self.status_label.set_text(&status);
+ self.resize_spread_pictures();
}
fn render_continuous(&self, visible: &[usize]) {
@@ -664,24 +2008,36 @@ impl ViewerController {
let old_bound = state.continuous_bound.clone();
let mut updates = Vec::new();
for index in old_bound.difference(&new_bound) {
- updates.push((state.continuous_rows[*index].picture.clone(), None));
+ let row = &state.continuous_rows[*index];
+ updates.push((
+ row.picture.clone(),
+ None,
+ Rc::clone(&row.animation_generation),
+ ));
}
for index in &new_bound {
state.access_clock = state.access_clock.wrapping_add(1);
let clock = state.access_clock;
- let texture = state.cache.get_mut(index).map(|page| {
+ let frames = state.cache.get_mut(index).map(|page| {
page.last_used = clock;
- page.texture.clone()
+ Rc::clone(&page.frames)
});
- updates.push((state.continuous_rows[*index].picture.clone(), texture));
+ let row = &state.continuous_rows[*index];
+ if !old_bound.contains(index) || row.picture.paintable().is_none() {
+ updates.push((
+ row.picture.clone(),
+ frames,
+ Rc::clone(&row.animation_generation),
+ ));
+ }
}
state.continuous_bound = new_bound;
let status = visible
.first()
.map(|index| state.pages[*index].name.clone());
drop(state);
- for (picture, texture) in updates {
- picture.set_paintable(texture.as_ref());
+ for (picture, frames, generation) in updates {
+ set_picture_animation(&picture, frames, &generation);
}
if let Some(status) = status {
self.status_label.set_text(&status);
@@ -689,13 +2045,16 @@ impl ViewerController {
}
fn continuous_scrolled(self: &Rc) {
- if self.view_mode() != ViewMode::Continuous || self.state.borrow().pages.is_empty() {
+ let pages_empty = self.state.borrow().pages.is_empty();
+ if self.view_mode() != ViewMode::Continuous || pages_empty {
return;
}
let visible = self.visible_indices();
let new_anchor = visible.first().copied();
- let changed = new_anchor.is_some_and(|index| index != self.state.borrow().anchor);
- if let Some(index) = new_anchor {
+ let update_anchor = !self.continuous_programmatic_scroll.get();
+ let changed =
+ update_anchor && new_anchor.is_some_and(|index| index != self.state.borrow().anchor);
+ if let Some(index) = new_anchor.filter(|_| update_anchor) {
self.state.borrow_mut().anchor = index;
}
self.render_continuous(&visible);
@@ -755,16 +2114,28 @@ impl ViewerController {
}
fn scroll_to_anchor(&self) {
- let state = self.state.borrow();
- let Some(row) = state.continuous_rows.get(state.anchor) else {
- return;
+ let frame = {
+ let state = self.state.borrow();
+ let Some(row) = state.continuous_rows.get(state.anchor) else {
+ return;
+ };
+ row.frame.clone()
};
- let Some(bounds) = row.frame.compute_bounds(&self.continuous_box) else {
+ let Some(bounds) = frame.compute_bounds(&self.continuous_box) else {
return;
};
let adjustment = self.continuous_scrolled.vadjustment();
let maximum = (adjustment.upper() - adjustment.page_size()).max(adjustment.lower());
- adjustment.set_value(f64::from(bounds.y()).clamp(adjustment.lower(), maximum));
+ let target = centered_scroll_value(
+ f64::from(bounds.y()),
+ f64::from(bounds.height()),
+ adjustment.page_size(),
+ adjustment.lower(),
+ maximum,
+ );
+ self.continuous_programmatic_scroll.set(true);
+ adjustment.set_value(target);
+ self.continuous_programmatic_scroll.set(false);
}
fn clear_continuous_paintables(&self) {
@@ -772,16 +2143,26 @@ impl ViewerController {
let indices: Vec<_> = state.continuous_bound.drain().collect();
let pictures: Vec<_> = indices
.into_iter()
- .map(|index| state.continuous_rows[index].picture.clone())
+ .map(|index| {
+ let row = &state.continuous_rows[index];
+ (row.picture.clone(), Rc::clone(&row.animation_generation))
+ })
.collect();
drop(state);
- for picture in pictures {
- picture.set_paintable(gdk::Paintable::NONE);
+ for (picture, generation) in pictures {
+ set_picture_animation(&picture, None, &generation);
}
}
fn resize_continuous_rows(&self) {
- let width = self.continuous_content_width();
+ let zoom = self.image_zoom.get();
+ let width = scaled_dimension(self.continuous_content_width(), zoom);
+ let zoomed = (zoom - 1.0).abs() >= f64::EPSILON;
+ self.continuous_box.set_halign(if zoomed {
+ gtk::Align::Center
+ } else {
+ gtk::Align::Fill
+ });
let rows: Vec<_> = self
.state
.borrow()
@@ -790,12 +2171,13 @@ impl ViewerController {
.map(|row| (row.frame.clone(), row.ratio))
.collect();
for (frame, ratio) in rows {
- frame.set_size_request(-1, row_height(width, ratio));
+ frame.set_hexpand(!zoomed);
+ frame.set_size_request(if zoomed { width } else { -1 }, row_height(width, ratio));
}
}
fn continuous_content_width(&self) -> i32 {
- (self.continuous_scrolled.allocated_width() - 24).max(320)
+ continuous_content_width(self.stack.width())
}
fn evict_cache(&self) {
@@ -838,26 +2220,1554 @@ impl ViewerController {
}
fn update_navigation(&self) {
- let state = self.state.borrow();
- let count = state.pages.len();
+ let (count, anchor) = {
+ let state = self.state.borrow();
+ (state.pages.len(), state.anchor)
+ };
if count == 0 {
self.page_label.set_text("- / -");
return;
}
let visible = self.visible_indices();
- let end = visible.last().copied().unwrap_or(state.anchor) + 1;
+ let end = visible.last().copied().unwrap_or(anchor) + 1;
if visible.len() > 1 && self.view_mode() == ViewMode::TwoPage {
self.page_label
- .set_text(&format!("{}-{end} / {count}", state.anchor + 1));
+ .set_text(&format!("{}-{end} / {count}", anchor + 1));
} else {
self.page_label
- .set_text(&format!("{} / {count}", state.anchor + 1));
+ .set_text(&format!("{} / {count}", anchor + 1));
}
- self.previous_button.set_sensitive(state.anchor > 0);
+ self.previous_button.set_sensitive(anchor > 0);
self.next_button.set_sensitive(end < count);
- self.shift_back_button.set_sensitive(state.anchor > 0);
- self.shift_forward_button
- .set_sensitive(state.anchor + 1 < count);
+ self.shift_back_button.set_sensitive(anchor > 0);
+ self.shift_forward_button.set_sensitive(anchor + 1 < count);
+ if (self.page_seek.value() - anchor as f64).abs() >= f64::EPSILON {
+ self.page_seek.set_value(anchor as f64);
+ }
+ }
+}
+
+pub struct MediaViewerWindow;
+
+impl MediaViewerWindow {
+ pub fn open(
+ application: >k::Application,
+ source: ArchiveSource,
+ kind: EntryKind,
+ controls: FileViewerControls,
+ ) {
+ let FileViewerControls {
+ sibling_navigator,
+ favorite_control,
+ download_control,
+ file_drop_control,
+ reuse_window,
+ view_mode_control,
+ two_page_direction_control: _,
+ } = controls;
+ let title_files = sibling_navigator
+ .as_ref()
+ .map(SiblingNavigator::files)
+ .unwrap_or_default();
+ let title = viewer_file_title(&source.display_name, &source.source_uri, &title_files);
+ let file_list_query = reuse_window
+ .as_ref()
+ .map(viewer_file_search_query)
+ .unwrap_or_default();
+ let file_list_scroll = reuse_window
+ .as_ref()
+ .map(viewer_file_scroll_position)
+ .unwrap_or_default();
+ let video_loop_active = reuse_window.as_ref().is_some_and(viewer_video_loop_enabled);
+ if let Some(window) = reuse_window.as_ref() {
+ clear_viewer_controller(window);
+ }
+ let window = reuse_window.unwrap_or_else(|| {
+ gtk::ApplicationWindow::builder()
+ .application(application)
+ .title(&title)
+ .default_width(1100)
+ .default_height(850)
+ .build()
+ });
+ install_file_drop_target(&window, file_drop_control);
+ ensure_viewer_close_handler(&window);
+ set_viewer_loading(&window, false);
+ window.set_title(Some(&title));
+ let header = gtk::HeaderBar::new();
+ header.set_title_widget(Some(&viewer_title_label(&title)));
+ let favorite_button = gtk::Button::with_label(favorite_label(favorite_control.active));
+ let download_button = gtk::Button::with_label("파일 다운로드");
+ let file_list_button = gtk::ToggleButton::with_label("파일 목록");
+ file_list_button.set_sensitive(sibling_navigator.is_some());
+ file_list_button.set_active(window.has_css_class("viewer-file-list-visible"));
+ let loop_check = gtk::CheckButton::with_label("반복 재생");
+ loop_check.set_active(video_loop_active);
+ loop_check.set_visible(kind == EntryKind::Video);
+ let image_mode_dropdown = gtk::DropDown::from_strings(&["100%", "폭 맞춤", "높이 맞춤"]);
+ let (image_mode_selected, image_mode_change) =
+ view_mode_control.map_or((1, None), |control| {
+ (
+ standalone_mode_index(control.selected),
+ Some(control.change),
+ )
+ });
+ image_mode_dropdown.set_selected(image_mode_selected);
+ image_mode_dropdown.set_visible(kind == EntryKind::Image);
+ header.pack_start(&image_mode_dropdown);
+ header.pack_end(&loop_check);
+ header.pack_end(&download_button);
+ header.pack_end(&favorite_button);
+ header.pack_end(&file_list_button);
+ let titlebar_host = set_viewer_header(&window, &header);
+
+ let root = gtk::Box::new(gtk::Orientation::Vertical, 0);
+ let stack = gtk::Stack::new();
+ stack.set_hexpand(true);
+ stack.set_vexpand(true);
+ let picture = page_picture();
+ let image_box = gtk::Box::new(gtk::Orientation::Horizontal, 0);
+ image_box.append(&picture);
+ let image_scrolled = gtk::ScrolledWindow::builder()
+ .hexpand(true)
+ .vexpand(true)
+ .child(&image_box)
+ .build();
+ stack.add_named(&image_scrolled, Some("image"));
+ let video = if kind == EntryKind::Video {
+ gtk::Video::for_filename(Some(&source.local_path))
+ } else {
+ gtk::Video::new()
+ };
+ video.set_autoplay(false);
+ video.set_loop(false);
+ video.set_hexpand(true);
+ video.set_vexpand(true);
+ stack.add_named(&video, Some("video"));
+ let status_label = gtk::Label::builder()
+ .label(&source.display_name)
+ .xalign(0.0)
+ .margin_top(6)
+ .margin_bottom(6)
+ .margin_start(8)
+ .margin_end(8)
+ .build();
+ let media_seek = navigation_scale();
+ let media_seek_row = navigation_scale_row(&media_seek);
+ let seek_files = sibling_navigator
+ .as_ref()
+ .map(|navigator| navigator.seek_files(kind))
+ .unwrap_or_default();
+ if let Some(current) = seek_position(&seek_files, &source.source_uri) {
+ let count = seek_files.len();
+ media_seek.set_range(0.0, navigation_scale_upper(count));
+ media_seek.set_value(current as f64);
+ media_seek.set_sensitive(count > 1);
+ } else {
+ media_seek.set_sensitive(false);
+ }
+ root.append(&stack);
+ root.append(&media_seek_row);
+ root.append(&status_label);
+ let window_overlay = gtk::Overlay::new();
+ window_overlay.set_child(Some(&root));
+ let (navigation_message, navigation_message_label) = navigation_message();
+ window_overlay.add_overlay(&navigation_message);
+ window_overlay.set_hexpand(true);
+ window_overlay.set_vexpand(true);
+ let file_list = viewer_file_list(&file_list_query);
+ file_list.panel.set_visible(file_list_button.is_active());
+ let viewer_layout = gtk::Box::new(gtk::Orientation::Horizontal, 0);
+ viewer_layout.append(&window_overlay);
+ viewer_layout.append(&file_list.panel);
+ window.set_child(Some(&viewer_layout));
+
+ let controller = Rc::new(MediaViewerController {
+ window,
+ titlebar_host,
+ source,
+ kind,
+ picture,
+ image_box,
+ image_scrolled,
+ image_mode_dropdown,
+ image_mode_change,
+ image_dimensions: Cell::new(None),
+ image_zoom: Cell::new(1.0),
+ image_animation_generation: Rc::new(AnimationState::default()),
+ video,
+ stack,
+ status_label,
+ media_seek,
+ media_seek_row,
+ seek_files: RefCell::new(seek_files),
+ sibling_navigator,
+ file_list_button,
+ file_list_panel: file_list.panel,
+ file_list_search: file_list.search,
+ file_list_scrolled: file_list.scrolled,
+ file_list: file_list.list,
+ file_list_files: RefCell::new(Vec::new()),
+ file_list_scroll_restore: Cell::new(Some(file_list_scroll)),
+ favorite_button,
+ favorite_toggle: favorite_control.toggle,
+ download_button,
+ file_download: download_control.download,
+ seek_generation: Cell::new(0),
+ seek_opening: Cell::new(false),
+ seek_hide_timer: RefCell::new(None),
+ seek_interacting: Cell::new(false),
+ pending_seek_index: Cell::new(None),
+ last_pointer_position: Cell::new(None),
+ key_controller: RefCell::new(None),
+ motion_controller: RefCell::new(None),
+ fullscreen_key_controller: RefCell::new(None),
+ fullscreen_click_controller: RefCell::new(None),
+ fullscreen_ui_hide_timer: RefCell::new(None),
+ fullscreen_ui_visible: Cell::new(false),
+ fullscreen_notify_handler: RefCell::new(None),
+ navigation_message,
+ navigation_message_label,
+ navigation_message_generation: Rc::new(Cell::new(0)),
+ });
+ if let Some(stream) = controller.video.media_stream() {
+ stream.set_loop(false);
+ let status_label = controller.status_label.clone();
+ stream.connect_error_notify(move |stream| {
+ if let Some(error) = stream.error() {
+ status_label.set_text(&format!("동영상을 재생할 수 없습니다: {error}"));
+ }
+ });
+ let restart_pending = Rc::new(Cell::new(false));
+ let loop_check_for_end = loop_check.downgrade();
+ let restart_pending_for_end = Rc::clone(&restart_pending);
+ stream.connect_ended_notify(move |stream| {
+ let Some(check) = loop_check_for_end.upgrade() else {
+ return;
+ };
+ schedule_video_loop_restart(stream, &check, &restart_pending_for_end);
+ });
+ let loop_check_for_timestamp = loop_check.downgrade();
+ let restart_pending_for_timestamp = Rc::clone(&restart_pending);
+ stream.connect_timestamp_notify(move |stream| {
+ let Some(check) = loop_check_for_timestamp.upgrade() else {
+ return;
+ };
+ schedule_video_loop_restart(stream, &check, &restart_pending_for_timestamp);
+ });
+ let stream_for_loop_check = stream.clone();
+ let window_for_loop_check = controller.window.clone();
+ loop_check.connect_toggled(move |check| {
+ store_viewer_video_loop(&window_for_loop_check, check.is_active());
+ schedule_video_loop_restart(&stream_for_loop_check, check, &restart_pending);
+ });
+ }
+ controller.connect_signals();
+ controller.fullscreen_changed();
+ if controller.window.has_css_class(PRESERVE_SEEK_CLASS) {
+ controller.window.remove_css_class(PRESERVE_SEEK_CLASS);
+ if controller.window.is_fullscreen() {
+ controller.show_fullscreen_ui_temporarily();
+ } else {
+ controller.show_seek_temporarily();
+ }
+ }
+ if controller.file_list_button.is_active() {
+ controller.refresh_file_list();
+ }
+ unsafe {
+ controller
+ .window
+ .set_data(MEDIA_VIEWER_CONTROLLER_KEY, Rc::clone(&controller));
+ }
+ controller.apply_image_view_mode();
+ controller.window.present();
+ match kind {
+ EntryKind::Image => controller.load_image(),
+ EntryKind::Video => {
+ controller.stack.set_visible_child_name("video");
+ if let Some(stream) = controller.video.media_stream() {
+ initialize_video_volume(&stream);
+ stream.play();
+ }
+ }
+ _ => {}
+ }
+ }
+}
+
+struct MediaViewerController {
+ window: gtk::ApplicationWindow,
+ titlebar_host: gtk::Box,
+ source: ArchiveSource,
+ kind: EntryKind,
+ picture: gtk::Picture,
+ image_box: gtk::Box,
+ image_scrolled: gtk::ScrolledWindow,
+ image_mode_dropdown: gtk::DropDown,
+ image_mode_change: Option>,
+ image_dimensions: Cell>,
+ image_zoom: Cell,
+ image_animation_generation: Rc,
+ video: gtk::Video,
+ stack: gtk::Stack,
+ status_label: gtk::Label,
+ media_seek: gtk::Scale,
+ media_seek_row: gtk::Box,
+ seek_files: RefCell>,
+ sibling_navigator: Option,
+ file_list_button: gtk::ToggleButton,
+ file_list_panel: gtk::Box,
+ file_list_search: gtk::SearchEntry,
+ file_list_scrolled: gtk::ScrolledWindow,
+ file_list: gtk::ListBox,
+ file_list_files: RefCell>,
+ file_list_scroll_restore: Cell>,
+ favorite_button: gtk::Button,
+ favorite_toggle: Rc bool>,
+ download_button: gtk::Button,
+ file_download: Rc,
+ seek_generation: Cell,
+ seek_opening: Cell,
+ seek_hide_timer: RefCell>,
+ seek_interacting: Cell,
+ pending_seek_index: Cell>,
+ last_pointer_position: Cell>,
+ key_controller: RefCell>,
+ motion_controller: RefCell>,
+ fullscreen_key_controller: RefCell>,
+ fullscreen_click_controller: RefCell>,
+ fullscreen_ui_hide_timer: RefCell>,
+ fullscreen_ui_visible: Cell,
+ fullscreen_notify_handler: RefCell>,
+ navigation_message: gtk::Box,
+ navigation_message_label: gtk::Label,
+ navigation_message_generation: Rc>,
+}
+
+impl MediaViewerController {
+ fn connect_signals(self: &Rc) {
+ let fullscreen_click = gtk::EventControllerLegacy::new();
+ fullscreen_click.set_propagation_phase(gtk::PropagationPhase::Capture);
+ let controller = Rc::downgrade(self);
+ fullscreen_click.connect_event(move |_, event| {
+ if event.downcast_ref::().is_some()
+ && event.event_type() == gdk::EventType::ButtonPress
+ && let Some(controller) = controller.upgrade()
+ {
+ controller.controls_clicked();
+ }
+ glib::Propagation::Proceed
+ });
+ self.window.add_controller(fullscreen_click.clone());
+ self.fullscreen_click_controller
+ .replace(Some(fullscreen_click));
+
+ let motion_controller = gtk::EventControllerMotion::new();
+ motion_controller.set_propagation_phase(gtk::PropagationPhase::Capture);
+ let controller = Rc::downgrade(self);
+ motion_controller.connect_motion(move |_, x, y| {
+ if let Some(controller) = controller.upgrade() {
+ controller.pointer_moved(x, y);
+ }
+ });
+ self.window.add_controller(motion_controller.clone());
+ self.motion_controller.replace(Some(motion_controller));
+
+ let fullscreen_keys = gtk::EventControllerKey::new();
+ fullscreen_keys.set_propagation_phase(gtk::PropagationPhase::Capture);
+ let controller = Rc::downgrade(self);
+ fullscreen_keys.connect_key_pressed(move |_, key, _, _| {
+ if let Some(controller) = controller.upgrade()
+ && !widget_contains_focus(&controller.file_list_search, &controller.window)
+ && controller.window.is_fullscreen()
+ && fullscreen_direction_key(key)
+ {
+ controller.hide_fullscreen_ui_now();
+ }
+ glib::Propagation::Proceed
+ });
+ self.window.add_controller(fullscreen_keys.clone());
+ self.fullscreen_key_controller
+ .replace(Some(fullscreen_keys));
+
+ let keys = gtk::EventControllerKey::new();
+ let controller = Rc::downgrade(self);
+ keys.connect_key_pressed(move |_, key, _, modifiers| {
+ let Some(controller) = controller.upgrade() else {
+ return glib::Propagation::Proceed;
+ };
+ if widget_contains_focus(&controller.file_list_search, &controller.window) {
+ return glib::Propagation::Proceed;
+ }
+ if modifiers.intersects(
+ gdk::ModifierType::CONTROL_MASK
+ | gdk::ModifierType::ALT_MASK
+ | gdk::ModifierType::SUPER_MASK,
+ ) {
+ return glib::Propagation::Proceed;
+ }
+ if !controller.window.is_fullscreen() {
+ controller.hide_seek();
+ }
+ match key {
+ gdk::Key::Left | gdk::Key::KP_Left if controller.kind == EntryKind::Video => {
+ controller.seek_video(-VIDEO_SEEK_STEP_US);
+ glib::Propagation::Stop
+ }
+ gdk::Key::Right | gdk::Key::KP_Right if controller.kind == EntryKind::Video => {
+ controller.seek_video(VIDEO_SEEK_STEP_US);
+ glib::Propagation::Stop
+ }
+ gdk::Key::Up | gdk::Key::KP_Up if controller.kind == EntryKind::Video => {
+ controller.adjust_video_volume(VIDEO_VOLUME_STEP);
+ glib::Propagation::Stop
+ }
+ gdk::Key::Down | gdk::Key::KP_Down if controller.kind == EntryKind::Video => {
+ controller.adjust_video_volume(-VIDEO_VOLUME_STEP);
+ glib::Propagation::Stop
+ }
+ gdk::Key::Home => {
+ controller.open_edge(false);
+ glib::Propagation::Stop
+ }
+ gdk::Key::End => {
+ controller.open_edge(true);
+ glib::Propagation::Stop
+ }
+ gdk::Key::Up | gdk::Key::KP_Up
+ if controller.kind == EntryKind::Image
+ && controller.pan_image(false, false) =>
+ {
+ glib::Propagation::Stop
+ }
+ gdk::Key::Down | gdk::Key::KP_Down
+ if controller.kind == EntryKind::Image && controller.pan_image(false, true) =>
+ {
+ glib::Propagation::Stop
+ }
+ gdk::Key::Left | gdk::Key::KP_Left
+ if controller.kind == EntryKind::Image && controller.pan_image(true, false) =>
+ {
+ glib::Propagation::Stop
+ }
+ gdk::Key::Right | gdk::Key::KP_Right
+ if controller.kind == EntryKind::Image && controller.pan_image(true, true) =>
+ {
+ glib::Propagation::Stop
+ }
+ _ if key.to_unicode() == Some('[') => {
+ controller.open_sibling(false);
+ glib::Propagation::Stop
+ }
+ _ if key.to_unicode() == Some(']') => {
+ controller.open_sibling(true);
+ glib::Propagation::Stop
+ }
+ gdk::Key::plus | gdk::Key::equal | gdk::Key::KP_Add
+ if controller.kind == EntryKind::Image =>
+ {
+ controller.adjust_image_zoom(true);
+ glib::Propagation::Stop
+ }
+ gdk::Key::minus | gdk::Key::KP_Subtract if controller.kind == EntryKind::Image => {
+ controller.adjust_image_zoom(false);
+ glib::Propagation::Stop
+ }
+ gdk::Key::_1 | gdk::Key::KP_1 if controller.kind == EntryKind::Image => {
+ controller.select_image_view_mode(1);
+ glib::Propagation::Stop
+ }
+ gdk::Key::_2 | gdk::Key::KP_2 if controller.kind == EntryKind::Image => {
+ controller.select_image_view_mode(2);
+ glib::Propagation::Stop
+ }
+ gdk::Key::_4 | gdk::Key::KP_4 if controller.kind == EntryKind::Image => {
+ controller.select_image_view_mode(0);
+ glib::Propagation::Stop
+ }
+ _ if key
+ .to_unicode()
+ .is_some_and(|character| character.eq_ignore_ascii_case(&'l')) =>
+ {
+ controller.toggle_file_list();
+ glib::Propagation::Stop
+ }
+ _ if key
+ .to_unicode()
+ .is_some_and(|character| character.eq_ignore_ascii_case(&'f')) =>
+ {
+ controller.toggle_fullscreen();
+ glib::Propagation::Stop
+ }
+ gdk::Key::Escape if controller.window.is_fullscreen() => {
+ controller.window.unfullscreen();
+ glib::Propagation::Stop
+ }
+ _ => glib::Propagation::Proceed,
+ }
+ });
+ self.window.add_controller(keys.clone());
+ self.key_controller.replace(Some(keys));
+ let controller = Rc::downgrade(self);
+ let handler = self
+ .window
+ .connect_notify_local(Some("fullscreened"), move |_, _| {
+ if let Some(controller) = controller.upgrade() {
+ controller.fullscreen_changed();
+ }
+ });
+ self.fullscreen_notify_handler.replace(Some(handler));
+ let controller = Rc::downgrade(self);
+ self.favorite_button.connect_clicked(move |_| {
+ if let Some(controller) = controller.upgrade() {
+ let active = (controller.favorite_toggle)();
+ controller.favorite_button.set_label(favorite_label(active));
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.download_button.connect_clicked(move |_| {
+ if let Some(controller) = controller.upgrade() {
+ (controller.file_download)(
+ controller.window.clone().upcast(),
+ controller.status_label.clone(),
+ );
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.file_list_button.connect_toggled(move |button| {
+ if let Some(controller) = controller.upgrade() {
+ controller.file_list_panel.set_visible(
+ button.is_active()
+ && (!controller.window.is_fullscreen()
+ || controller.fullscreen_ui_visible.get()),
+ );
+ if button.is_active() {
+ controller.window.add_css_class("viewer-file-list-visible");
+ } else {
+ controller
+ .window
+ .remove_css_class("viewer-file-list-visible");
+ }
+ if button.is_active() {
+ controller.refresh_file_list();
+ }
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.file_list.connect_row_activated(move |_, row| {
+ if let Some(controller) = controller.upgrade() {
+ controller.open_file_list_row(row.index());
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.file_list_search.connect_search_changed(move |search| {
+ if let Some(controller) = controller.upgrade() {
+ store_viewer_file_search_query(&controller.window, search.text().as_str());
+ controller.refresh_file_list();
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.file_list_scrolled
+ .vadjustment()
+ .connect_value_changed(move |adjustment| {
+ if let Some(controller) = controller.upgrade()
+ && controller.file_list_scroll_restore.get().is_none()
+ {
+ store_viewer_file_scroll_position(&controller.window, adjustment.value());
+ }
+ });
+ let file_list_typeahead = Rc::new(RefCell::new(TypeaheadBuffer::default()));
+ let file_list_keys = gtk::EventControllerKey::new();
+ let controller = Rc::downgrade(self);
+ file_list_keys.connect_key_pressed(move |_, key, _, modifiers| {
+ let Some(controller) = controller.upgrade() else {
+ return glib::Propagation::Proceed;
+ };
+ file_list_typeahead_select(
+ &controller.file_list,
+ &controller.file_list_files.borrow(),
+ &mut file_list_typeahead.borrow_mut(),
+ key,
+ modifiers,
+ )
+ });
+ self.file_list.add_controller(file_list_keys);
+ let file_list_click = gtk::GestureClick::builder().button(3).build();
+ let controller = Rc::downgrade(self);
+ file_list_click.connect_pressed(move |_, _, x, y| {
+ if let Some(controller) = controller.upgrade() {
+ controller.show_file_list_context_menu(x, y);
+ }
+ });
+ self.file_list.add_controller(file_list_click);
+ if let Some(change) = self.image_mode_change.clone() {
+ let controller = Rc::downgrade(self);
+ self.image_mode_dropdown
+ .connect_selected_notify(move |dropdown| {
+ if let Some(controller) = controller.upgrade() {
+ change(dropdown.selected());
+ controller.image_zoom.set(1.0);
+ controller.apply_image_view_mode();
+ }
+ });
+ }
+ let controller = Rc::downgrade(self);
+ self.image_scrolled
+ .connect_notify_local(Some("width"), move |_, _| {
+ if let Some(controller) = controller.upgrade() {
+ controller.resize_image_picture();
+ }
+ });
+ let controller = Rc::downgrade(self);
+ self.image_scrolled
+ .connect_notify_local(Some("height"), move |_, _| {
+ if let Some(controller) = controller.upgrade() {
+ controller.resize_image_picture();
+ }
+ });
+ let image_scroll = gtk::EventControllerScroll::new(
+ gtk::EventControllerScrollFlags::VERTICAL | gtk::EventControllerScrollFlags::DISCRETE,
+ );
+ image_scroll.set_propagation_phase(gtk::PropagationPhase::Capture);
+ let controller = Rc::downgrade(self);
+ image_scroll.connect_scroll(move |scroll, _, delta_y| {
+ let Some(controller) = controller.upgrade() else {
+ return glib::Propagation::Proceed;
+ };
+ if controller.kind == EntryKind::Image
+ && scroll
+ .current_event_state()
+ .contains(gdk::ModifierType::CONTROL_MASK)
+ && delta_y != 0.0
+ {
+ controller.adjust_image_zoom(delta_y < 0.0);
+ glib::Propagation::Stop
+ } else {
+ glib::Propagation::Proceed
+ }
+ });
+ self.image_scrolled.add_controller(image_scroll);
+ let controller = Rc::downgrade(self);
+ self.media_seek.connect_value_changed(move |scale| {
+ let Some(controller) = controller.upgrade() else {
+ return;
+ };
+ let count = controller.seek_files.borrow().len();
+ let Some(index) = page_seek_index(scale.value(), count) else {
+ return;
+ };
+ if controller.seek_interacting.get() {
+ controller.pending_seek_index.set(Some(index));
+ } else {
+ controller.schedule_seek(index);
+ }
+ });
+ let seek_events = gtk::EventControllerLegacy::new();
+ seek_events.set_propagation_phase(gtk::PropagationPhase::Capture);
+ let controller = Rc::downgrade(self);
+ seek_events.connect_event(move |_, event| {
+ if event
+ .downcast_ref::()
+ .is_some_and(|event| event.button() == gdk::BUTTON_PRIMARY)
+ && let Some(controller) = controller.upgrade()
+ {
+ match event.event_type() {
+ gdk::EventType::ButtonPress => controller.begin_seek_interaction(),
+ gdk::EventType::ButtonRelease => controller.end_seek_interaction(),
+ _ => {}
+ }
+ }
+ glib::Propagation::Proceed
+ });
+ self.media_seek.add_controller(seek_events);
+ }
+
+ fn refresh_file_list(&self) {
+ while let Some(child) = self.file_list.first_child() {
+ self.file_list.remove(&child);
+ }
+ let files = self
+ .sibling_navigator
+ .as_ref()
+ .map(SiblingNavigator::files)
+ .unwrap_or_default();
+ let files = filter_sibling_files(files, self.file_list_search.text().as_str());
+ let current = files
+ .iter()
+ .position(|file| file.uri == self.source.source_uri);
+ for file in &files {
+ self.file_list.append(&viewer_file_row(file));
+ }
+ *self.file_list_files.borrow_mut() = files;
+ if let Some(row) = current.and_then(|index| self.file_list.row_at_index(index as i32)) {
+ self.file_list.select_row(Some(&row));
+ }
+ restore_pending_viewer_file_scroll(
+ &self.file_list_panel,
+ &self.file_list_scrolled,
+ &self.file_list_scroll_restore,
+ );
+ }
+
+ fn open_file_list_row(&self, index: i32) {
+ let Some(uri) = self
+ .file_list_files
+ .borrow()
+ .get(index as usize)
+ .map(|file| file.uri.clone())
+ else {
+ return;
+ };
+ if uri == self.source.source_uri {
+ return;
+ }
+ if let Some(navigator) = &self.sibling_navigator
+ && navigator.open_uri(&uri, self.window.clone())
+ {
+ self.prepare_for_navigation();
+ }
+ }
+
+ fn show_file_list_context_menu(&self, x: f64, y: f64) {
+ let Some((row, file)) = selected_viewer_file(&self.file_list, &self.file_list_files, x, y)
+ else {
+ return;
+ };
+ self.file_list.select_row(Some(&row));
+ let Some(actions) = self
+ .sibling_navigator
+ .as_ref()
+ .and_then(|navigator| navigator.actions(&file.uri))
+ else {
+ return;
+ };
+ show_viewer_file_context_menu(
+ &row,
+ &file,
+ actions,
+ &self.source.source_uri,
+ &self.favorite_button,
+ &self.window,
+ &self.status_label,
+ );
+ }
+
+ fn image_view_mode(&self) -> ViewMode {
+ match self.image_mode_dropdown.selected() {
+ 0 => ViewMode::ActualSize,
+ 2 => ViewMode::FitHeight,
+ _ => ViewMode::FitWidth,
+ }
+ }
+
+ fn toggle_file_list(&self) {
+ if !self.file_list_button.is_sensitive() {
+ return;
+ }
+ let active = !self.file_list_button.is_active();
+ self.file_list_button.set_active(active);
+ if self.window.is_fullscreen() {
+ self.file_list_panel.set_visible(active);
+ }
+ }
+
+ fn seek_video(&self, delta: i64) {
+ let Some(stream) = self
+ .video
+ .media_stream()
+ .filter(|stream| stream.is_seekable())
+ else {
+ return;
+ };
+ stream.seek(video_seek_target(
+ stream.timestamp(),
+ stream.duration(),
+ delta,
+ ));
+ }
+
+ fn adjust_video_volume(&self, delta: f64) {
+ let Some(stream) = self.video.media_stream() else {
+ return;
+ };
+ stream.set_volume(video_volume_target(stream.volume(), delta));
+ }
+
+ fn apply_image_view_mode(&self) {
+ if self.kind != EntryKind::Image {
+ return;
+ }
+ let mode = self.image_view_mode();
+ let actual = mode == ViewMode::ActualSize;
+ self.image_box.set_hexpand(!actual);
+ self.image_box.set_vexpand(mode == ViewMode::FitHeight);
+ self.image_box.set_halign(match mode {
+ ViewMode::ActualSize => gtk::Align::Start,
+ ViewMode::FitHeight => gtk::Align::Center,
+ _ => gtk::Align::Fill,
+ });
+ self.image_box.set_valign(if actual {
+ gtk::Align::Start
+ } else {
+ gtk::Align::Fill
+ });
+ self.picture.set_can_shrink(!actual);
+ self.picture.set_hexpand(mode == ViewMode::FitWidth);
+ self.picture.set_vexpand(mode == ViewMode::FitHeight);
+ if matches!(mode, ViewMode::ActualSize | ViewMode::FitWidth) {
+ self.picture.set_content_fit(gtk::ContentFit::Fill);
+ self.picture.set_halign(if actual {
+ gtk::Align::Start
+ } else {
+ gtk::Align::Fill
+ });
+ self.picture.set_valign(gtk::Align::Start);
+ } else {
+ self.picture.set_content_fit(gtk::ContentFit::Contain);
+ self.picture.set_halign(if mode == ViewMode::FitHeight {
+ gtk::Align::Center
+ } else {
+ gtk::Align::Fill
+ });
+ self.picture.set_valign(gtk::Align::Fill);
+ self.picture.set_size_request(-1, -1);
+ }
+ self.resize_image_picture();
+ self.stack.queue_allocate();
+ }
+
+ fn adjust_image_zoom(&self, zoom_in: bool) {
+ if self.kind != EntryKind::Image {
+ return;
+ }
+ let zoom = next_image_zoom(self.image_zoom.get(), zoom_in);
+ if (zoom - self.image_zoom.get()).abs() < f64::EPSILON {
+ return;
+ }
+ self.image_zoom.set(zoom);
+ if (zoom - 1.0).abs() < f64::EPSILON {
+ self.apply_image_view_mode();
+ } else {
+ self.resize_image_picture();
+ self.stack.queue_allocate();
+ }
+ }
+
+ fn select_image_view_mode(&self, index: u32) {
+ if self.image_mode_dropdown.selected() != index {
+ self.image_mode_dropdown.set_selected(index);
+ } else {
+ self.image_zoom.set(1.0);
+ self.apply_image_view_mode();
+ }
+ }
+
+ fn resize_image_picture(&self) {
+ let Some((texture_width, texture_height)) = self.image_dimensions.get() else {
+ return;
+ };
+ let zoom = self.image_zoom.get();
+ if (zoom - 1.0).abs() >= f64::EPSILON {
+ let (width, height) = zoomed_picture_request(
+ self.image_view_mode(),
+ self.image_scrolled.width().max(1),
+ self.image_scrolled.height().max(1),
+ texture_width,
+ texture_height,
+ zoom,
+ );
+ self.image_box.set_hexpand(true);
+ self.image_box.set_vexpand(true);
+ self.image_box.set_halign(gtk::Align::Fill);
+ self.image_box.set_valign(gtk::Align::Fill);
+ self.picture.set_can_shrink(false);
+ self.picture.set_hexpand(false);
+ self.picture.set_vexpand(false);
+ self.picture.set_content_fit(gtk::ContentFit::Fill);
+ self.picture.set_halign(gtk::Align::Center);
+ self.picture.set_valign(gtk::Align::Center);
+ self.picture.set_size_request(width, height);
+ } else if let Some((width, height)) = single_picture_request(
+ self.image_view_mode(),
+ self.stack.width().max(1),
+ texture_width,
+ texture_height,
+ ) {
+ self.picture.set_size_request(width, height);
+ }
+ }
+
+ fn pan_image(&self, horizontal: bool, forward: bool) -> bool {
+ let adjustment = if horizontal {
+ self.image_scrolled.hadjustment()
+ } else {
+ self.image_scrolled.vadjustment()
+ };
+ pan_adjustment(&adjustment, forward)
+ }
+
+ fn open_sibling(&self, forward: bool) {
+ if let Some(navigate) = &self.sibling_navigator
+ && navigate.open_relative(forward, self.window.clone())
+ {
+ self.prepare_for_navigation();
+ } else {
+ self.show_navigation_error(forward);
+ }
+ }
+
+ fn open_edge(&self, end: bool) {
+ if let Some(navigate) = &self.sibling_navigator
+ && navigate.open_edge(end, self.window.clone())
+ {
+ self.prepare_for_navigation();
+ } else {
+ self.show_navigation_error(end);
+ }
+ }
+
+ fn show_navigation_error(&self, forward: bool) {
+ self.navigation_message_label
+ .set_text(navigation_error_message(forward));
+ self.navigation_message.set_visible(true);
+ let message = self.navigation_message.clone();
+ let generation = self.navigation_message_generation.get().wrapping_add(1);
+ self.navigation_message_generation.set(generation);
+ let current_generation = Rc::clone(&self.navigation_message_generation);
+ glib::timeout_add_local_once(Duration::from_secs(2), move || {
+ if current_generation.get() == generation {
+ message.set_visible(false);
+ }
+ });
+ }
+
+ fn show_seek_temporarily(self: &Rc) {
+ if let Some(timer) = self.seek_hide_timer.borrow_mut().take() {
+ timer.remove();
+ }
+ let seek_files = self.seek_files.borrow();
+ if let Some(current) = seek_position(&seek_files, &self.source.source_uri) {
+ let count = seek_files.len();
+ self.media_seek
+ .set_range(0.0, navigation_scale_upper(count));
+ self.media_seek.set_sensitive(count > 1);
+ self.media_seek.set_value(current as f64);
+ }
+ self.set_seek_visible(true);
+ let controller = Rc::downgrade(self);
+ let timer = glib::timeout_add_local_once(Duration::from_secs(5), move || {
+ if let Some(controller) = controller.upgrade() {
+ controller.seek_hide_timer.borrow_mut().take();
+ if !controller.seek_interacting.get() {
+ controller.set_seek_visible(false);
+ }
+ }
+ });
+ self.seek_hide_timer.replace(Some(timer));
+ }
+
+ fn begin_seek_interaction(self: &Rc) {
+ self.seek_interacting.set(true);
+ self.pending_seek_index.set(None);
+ self.seek_generation
+ .set(self.seek_generation.get().wrapping_add(1));
+ if let Some(timer) = self.seek_hide_timer.borrow_mut().take() {
+ timer.remove();
+ }
+ self.cancel_fullscreen_ui_timer();
+ if self.window.is_fullscreen() {
+ self.set_fullscreen_ui_visible(true);
+ } else {
+ self.set_seek_visible(true);
+ }
+ }
+
+ fn end_seek_interaction(self: &Rc) {
+ if !self.seek_interacting.replace(false) {
+ return;
+ }
+ if self.window.is_fullscreen() {
+ self.show_fullscreen_ui_temporarily();
+ } else {
+ self.show_seek_temporarily();
+ }
+ if let Some(index) = self.pending_seek_index.take() {
+ self.schedule_seek(index);
+ }
+ }
+
+ fn pointer_moved(self: &Rc, x: f64, y: f64) {
+ if self.last_pointer_position.get() == Some((x, y)) {
+ return;
+ }
+ self.last_pointer_position.set(Some((x, y)));
+ }
+
+ fn controls_clicked(self: &Rc) {
+ if self.window.is_fullscreen() {
+ self.show_fullscreen_ui_temporarily();
+ } else {
+ self.show_seek_temporarily();
+ }
+ }
+
+ fn hide_seek(self: &Rc) {
+ if let Some(timer) = self.seek_hide_timer.borrow_mut().take() {
+ timer.remove();
+ }
+ if !self.seek_interacting.get() {
+ self.set_seek_visible(false);
+ }
+ }
+
+ fn set_seek_visible(self: &Rc, visible: bool) {
+ if self.media_seek_row.is_visible() == visible {
+ return;
+ }
+ self.media_seek_row.set_visible(visible);
+ self.window.queue_allocate();
+ let controller = Rc::downgrade(self);
+ glib::idle_add_local_once(move || {
+ if let Some(controller) = controller.upgrade() {
+ controller.stack.queue_allocate();
+ controller.picture.queue_allocate();
+ controller.video.queue_allocate();
+ }
+ });
+ }
+
+ fn schedule_seek(self: &Rc, index: usize) {
+ if self.sibling_navigator.is_none() {
+ return;
+ }
+ let Some(file) = self.seek_files.borrow().get(index).cloned() else {
+ return;
+ };
+ if file.uri == self.source.source_uri || self.seek_opening.get() {
+ return;
+ }
+ let generation = self.seek_generation.get().wrapping_add(1);
+ self.seek_generation.set(generation);
+ let controller = Rc::downgrade(self);
+ glib::timeout_add_local_once(Duration::from_millis(180), move || {
+ let Some(controller) = controller.upgrade() else {
+ return;
+ };
+ if controller.seek_generation.get() != generation || controller.seek_opening.get() {
+ return;
+ }
+ let Some(navigator) = &controller.sibling_navigator else {
+ return;
+ };
+ let Some(uri) = controller
+ .seek_files
+ .borrow()
+ .get(index)
+ .map(|file| file.uri.clone())
+ else {
+ return;
+ };
+ controller.seek_opening.set(true);
+ controller.window.add_css_class(PRESERVE_SEEK_CLASS);
+ if navigator.open_uri(&uri, controller.window.clone()) {
+ controller.prepare_for_navigation();
+ } else {
+ controller.seek_opening.set(false);
+ controller.window.remove_css_class(PRESERVE_SEEK_CLASS);
+ }
+ });
+ }
+
+ fn prepare_for_navigation(&self) {
+ self.seek_generation
+ .set(self.seek_generation.get().wrapping_add(1));
+ self.stop_playback();
+ if let Some(timer) = self.seek_hide_timer.borrow_mut().take() {
+ timer.remove();
+ }
+ self.cancel_fullscreen_ui_timer();
+ if let Some(handler) = self.fullscreen_notify_handler.borrow_mut().take() {
+ self.window.disconnect(handler);
+ }
+ if let Some(controller) = self.key_controller.borrow_mut().take() {
+ self.window.remove_controller(&controller);
+ }
+ if let Some(controller) = self.motion_controller.borrow_mut().take() {
+ self.window.remove_controller(&controller);
+ }
+ if let Some(controller) = self.fullscreen_key_controller.borrow_mut().take() {
+ self.window.remove_controller(&controller);
+ }
+ if let Some(controller) = self.fullscreen_click_controller.borrow_mut().take() {
+ self.window.remove_controller(&controller);
+ }
+ }
+
+ fn stop_playback(&self) {
+ self.image_animation_generation.cancel();
+ if let Some(stream) = self.video.media_stream() {
+ stream.pause();
+ }
+ }
+
+ fn toggle_fullscreen(&self) {
+ if self.window.is_fullscreen() {
+ self.window.unfullscreen();
+ } else {
+ self.window.fullscreen();
+ }
+ }
+
+ fn fullscreen_changed(self: &Rc) {
+ self.cancel_fullscreen_ui_timer();
+ self.hide_seek();
+ if self.window.is_fullscreen() {
+ self.set_fullscreen_ui_visible(false);
+ } else {
+ self.fullscreen_ui_visible.set(true);
+ self.titlebar_host.set_visible(true);
+ self.status_label.set_visible(true);
+ self.file_list_panel
+ .set_visible(self.file_list_button.is_active());
+ restore_pending_viewer_file_scroll(
+ &self.file_list_panel,
+ &self.file_list_scrolled,
+ &self.file_list_scroll_restore,
+ );
+ }
+ }
+
+ fn show_fullscreen_ui_temporarily(self: &Rc) {
+ if !self.window.is_fullscreen() {
+ return;
+ }
+ self.cancel_fullscreen_ui_timer();
+ self.set_fullscreen_ui_visible(true);
+ let controller = Rc::downgrade(self);
+ let timer = glib::timeout_add_local_once(Duration::from_secs(5), move || {
+ if let Some(controller) = controller.upgrade() {
+ controller.fullscreen_ui_hide_timer.borrow_mut().take();
+ controller.set_fullscreen_ui_visible(false);
+ }
+ });
+ self.fullscreen_ui_hide_timer.replace(Some(timer));
+ }
+
+ fn hide_fullscreen_ui_now(self: &Rc) {
+ if self.window.is_fullscreen() && !self.seek_interacting.get() {
+ self.cancel_fullscreen_ui_timer();
+ self.set_fullscreen_ui_visible(false);
+ }
+ }
+
+ fn cancel_fullscreen_ui_timer(&self) {
+ if let Some(timer) = self.fullscreen_ui_hide_timer.borrow_mut().take() {
+ timer.remove();
+ }
+ }
+
+ fn set_fullscreen_ui_visible(self: &Rc, visible: bool) {
+ self.fullscreen_ui_visible.set(visible);
+ self.titlebar_host.set_visible(visible);
+ self.media_seek_row.set_visible(visible);
+ self.status_label.set_visible(visible);
+ self.file_list_panel
+ .set_visible(visible && self.file_list_button.is_active());
+ restore_pending_viewer_file_scroll(
+ &self.file_list_panel,
+ &self.file_list_scrolled,
+ &self.file_list_scroll_restore,
+ );
+ self.window.queue_allocate();
+ let controller = Rc::downgrade(self);
+ glib::idle_add_local_once(move || {
+ if let Some(controller) = controller.upgrade() {
+ controller.stack.queue_allocate();
+ controller.picture.queue_allocate();
+ controller.video.queue_allocate();
+ controller.resize_image_picture();
+ }
+ });
+ }
+
+ fn load_image(self: &Rc) {
+ self.stack.set_visible_child_name("image");
+ self.status_label.set_text("이미지를 읽는 중...");
+ let path = self.source.local_path.clone();
+ let display_name = self.source.display_name.clone();
+ let (sender, receiver) = mpsc::channel();
+ thread::spawn(move || {
+ let result =
+ decode_image_file(&path, &display_name).map_err(|error| format!("{error:#}"));
+ let _ = sender.send(result);
+ });
+ let controller = Rc::downgrade(self);
+ glib::timeout_add_local(Duration::from_millis(20), move || {
+ match receiver.try_recv() {
+ Ok(result) => {
+ if let Some(controller) = controller.upgrade() {
+ controller.finish_image_load(result);
+ }
+ glib::ControlFlow::Break
+ }
+ Err(TryRecvError::Empty) => glib::ControlFlow::Continue,
+ Err(TryRecvError::Disconnected) => glib::ControlFlow::Break,
+ }
+ });
+ }
+
+ fn finish_image_load(&self, result: Result) {
+ match result {
+ Ok(page) => {
+ self.image_dimensions
+ .set(Some((page.width as i32, page.height as i32)));
+ let (frames, _) = texture_frames(page);
+ set_picture_animation(
+ &self.picture,
+ Some(frames),
+ &self.image_animation_generation,
+ );
+ self.apply_image_view_mode();
+ self.status_label.set_text(&self.source.display_name);
+ }
+ Err(error) => self.status_label.set_text(&error),
+ }
+ }
+}
+
+fn favorite_label(active: bool) -> &'static str {
+ if active {
+ "즐겨찾기 제거"
+ } else {
+ "즐겨찾기 추가"
+ }
+}
+
+fn viewer_title_label(title: &str) -> gtk::Label {
+ gtk::Label::builder()
+ .label(title)
+ .hexpand(true)
+ .ellipsize(gtk::pango::EllipsizeMode::Middle)
+ .tooltip_text(title)
+ .build()
+}
+
+fn viewer_file_title(display_name: &str, current_uri: &str, files: &[SiblingFile]) -> String {
+ seek_position(files, current_uri).map_or_else(
+ || display_name.to_owned(),
+ |index| format!("{display_name} ({}/{})", index + 1, files.len()),
+ )
+}
+
+struct ViewerFileList {
+ panel: gtk::Box,
+ search: gtk::SearchEntry,
+ scrolled: gtk::ScrolledWindow,
+ list: gtk::ListBox,
+}
+
+#[derive(Default)]
+struct TypeaheadBuffer {
+ query: String,
+ last_input: Option,
+}
+
+fn file_list_typeahead_select(
+ list: >k::ListBox,
+ files: &[SiblingFile],
+ state: &mut TypeaheadBuffer,
+ key: gdk::Key,
+ modifiers: gdk::ModifierType,
+) -> glib::Propagation {
+ let blocked = gdk::ModifierType::CONTROL_MASK
+ | gdk::ModifierType::ALT_MASK
+ | gdk::ModifierType::SUPER_MASK;
+ if modifiers.intersects(blocked) {
+ return glib::Propagation::Proceed;
+ }
+ if key == gdk::Key::Escape {
+ state.query.clear();
+ state.last_input = None;
+ return glib::Propagation::Proceed;
+ }
+ if matches!(key, gdk::Key::space)
+ || key.to_unicode().is_some_and(|character| {
+ character.eq_ignore_ascii_case(&'f')
+ || character.eq_ignore_ascii_case(&'l')
+ || matches!(character, '[' | ']' | '+' | '-')
+ })
+ {
+ return glib::Propagation::Proceed;
+ }
+ let now = Instant::now();
+ if state
+ .last_input
+ .is_none_or(|last| now.duration_since(last) > Duration::from_millis(1200))
+ {
+ state.query.clear();
+ }
+ if key == gdk::Key::BackSpace {
+ return if state.query.pop().is_some() {
+ state.last_input = Some(now);
+ glib::Propagation::Stop
+ } else {
+ glib::Propagation::Proceed
+ };
+ }
+ let Some(character) = key.to_unicode().filter(|character| !character.is_control()) else {
+ return glib::Propagation::Proceed;
+ };
+ let input = character.to_lowercase().collect::();
+ let repeated_single = state.query.chars().count() == 1 && state.query == input;
+ if !repeated_single {
+ state.query.push_str(&input);
+ }
+ state.last_input = Some(now);
+ let selected = list.selected_row().map(|row| row.index() as usize);
+ let start = if repeated_single {
+ selected.map_or(0, |index| index + 1)
+ } else {
+ 0
+ };
+ let found = find_sibling_prefix(files, &state.query, start);
+ if let Some(row) = found.and_then(|index| list.row_at_index(index as i32)) {
+ list.select_row(Some(&row));
+ let _ = row.grab_focus();
+ }
+ glib::Propagation::Stop
+}
+
+fn fullscreen_direction_key(key: gdk::Key) -> bool {
+ matches!(
+ key,
+ gdk::Key::Left
+ | gdk::Key::Right
+ | gdk::Key::Up
+ | gdk::Key::Down
+ | gdk::Key::KP_Left
+ | gdk::Key::KP_Right
+ | gdk::Key::KP_Up
+ | gdk::Key::KP_Down
+ )
+}
+
+fn shortcut_modifiers_blocked(modifiers: gdk::ModifierType) -> bool {
+ modifiers.intersects(
+ gdk::ModifierType::CONTROL_MASK
+ | gdk::ModifierType::ALT_MASK
+ | gdk::ModifierType::SUPER_MASK,
+ )
+}
+
+fn find_sibling_prefix(files: &[SiblingFile], query: &str, start: usize) -> Option {
+ if files.is_empty() {
+ return None;
+ }
+ let query = query.to_lowercase();
+ (0..files.len())
+ .map(|offset| (start + offset) % files.len())
+ .find(|index| files[*index].name.to_lowercase().starts_with(&query))
+}
+
+fn viewer_file_list(query: &str) -> ViewerFileList {
+ let search = gtk::SearchEntry::builder()
+ .placeholder_text("재생 목록 검색")
+ .margin_top(8)
+ .margin_bottom(8)
+ .margin_start(8)
+ .margin_end(8)
+ .build();
+ search.set_text(query);
+ let list = gtk::ListBox::new();
+ list.set_selection_mode(gtk::SelectionMode::Single);
+ list.set_activate_on_single_click(false);
+ let scrolled = gtk::ScrolledWindow::builder()
+ .vexpand(true)
+ .child(&list)
+ .build();
+ let panel = gtk::Box::new(gtk::Orientation::Vertical, 0);
+ panel.set_width_request(280);
+ panel.set_vexpand(true);
+ panel.append(&search);
+ panel.append(&scrolled);
+ panel.add_css_class("sidebar");
+ panel.set_visible(false);
+ ViewerFileList {
+ panel,
+ search,
+ scrolled,
+ list,
+ }
+}
+
+fn viewer_file_search_query(window: >k::ApplicationWindow) -> String {
+ unsafe {
+ window
+ .data::(VIEWER_FILE_SEARCH_KEY)
+ .map(|query| query.as_ref().clone())
+ .unwrap_or_default()
+ }
+}
+
+fn store_viewer_file_search_query(window: >k::ApplicationWindow, query: &str) {
+ unsafe {
+ window.set_data(VIEWER_FILE_SEARCH_KEY, query.to_owned());
+ }
+}
+
+fn viewer_file_scroll_position(window: >k::ApplicationWindow) -> f64 {
+ unsafe {
+ window
+ .data::(VIEWER_FILE_SCROLL_KEY)
+ .map(|position| *position.as_ref())
+ .unwrap_or_default()
+ }
+}
+
+fn store_viewer_file_scroll_position(window: >k::ApplicationWindow, position: f64) {
+ unsafe {
+ window.set_data(VIEWER_FILE_SCROLL_KEY, position.max(0.0));
+ }
+}
+
+fn viewer_video_loop_enabled(window: >k::ApplicationWindow) -> bool {
+ unsafe {
+ window
+ .data::(VIEWER_VIDEO_LOOP_KEY)
+ .is_some_and(|active| *active.as_ref())
+ }
+}
+
+fn store_viewer_video_loop(window: >k::ApplicationWindow, active: bool) {
+ unsafe {
+ window.set_data(VIEWER_VIDEO_LOOP_KEY, active);
+ }
+}
+
+fn restore_viewer_file_scroll(scrolled: >k::ScrolledWindow, position: f64) {
+ let scrolled = scrolled.clone();
+ glib::idle_add_local_once(move || {
+ let adjustment = scrolled.vadjustment();
+ let maximum = (adjustment.upper() - adjustment.page_size()).max(adjustment.lower());
+ adjustment.set_value(position.clamp(adjustment.lower(), maximum));
+ });
+}
+
+fn restore_pending_viewer_file_scroll(
+ panel: >k::Box,
+ scrolled: >k::ScrolledWindow,
+ pending: &Cell>,
+) {
+ if !panel.is_visible() {
+ return;
+ }
+ if let Some(position) = pending.take() {
+ restore_viewer_file_scroll(scrolled, position);
+ }
+}
+
+fn widget_contains_focus(widget: &impl IsA, window: >k::ApplicationWindow) -> bool {
+ gtk::prelude::GtkWindowExt::focus(window).is_some_and(|focus| {
+ let widget = widget.as_ref();
+ focus == *widget || focus.is_ancestor(widget)
+ })
+}
+
+fn viewer_file_row(file: &SiblingFile) -> gtk::ListBoxRow {
+ let row = gtk::ListBoxRow::new();
+ let content = gtk::Box::new(gtk::Orientation::Horizontal, 8);
+ content.set_margin_top(7);
+ content.set_margin_bottom(7);
+ content.set_margin_start(8);
+ content.set_margin_end(8);
+ let icon_name = match file.kind {
+ EntryKind::ZipArchive => "package-x-generic-symbolic",
+ EntryKind::Video => "video-x-generic-symbolic",
+ _ => "image-x-generic-symbolic",
+ };
+ let icon = gtk::Image::from_icon_name(icon_name);
+ let label = gtk::Label::builder()
+ .label(&file.name)
+ .xalign(0.0)
+ .hexpand(true)
+ .ellipsize(gtk::pango::EllipsizeMode::Middle)
+ .tooltip_text(&file.name)
+ .build();
+ content.append(&icon);
+ content.append(&label);
+ row.set_child(Some(&content));
+ row
+}
+
+fn selected_viewer_file(
+ list: >k::ListBox,
+ files: &RefCell>,
+ x: f64,
+ y: f64,
+) -> Option<(gtk::ListBoxRow, SiblingFile)> {
+ let widget = list.pick(x, y, gtk::PickFlags::DEFAULT)?;
+ let row = widget
+ .clone()
+ .downcast::()
+ .ok()
+ .or_else(|| {
+ widget
+ .ancestor(gtk::ListBoxRow::static_type())
+ .and_then(|widget| widget.downcast::().ok())
+ })?;
+ let file = files.borrow().get(row.index() as usize)?.clone();
+ Some((row, file))
+}
+
+fn show_viewer_file_context_menu(
+ row: >k::ListBoxRow,
+ file: &SiblingFile,
+ actions: SiblingFileActions,
+ current_uri: &str,
+ current_favorite_button: >k::Button,
+ window: >k::ApplicationWindow,
+ status_label: >k::Label,
+) {
+ let popover = gtk::Popover::new();
+ popover.set_parent(row);
+ let buttons = gtk::Box::new(gtk::Orientation::Vertical, 4);
+ buttons.set_margin_top(6);
+ buttons.set_margin_bottom(6);
+ buttons.set_margin_start(6);
+ buttons.set_margin_end(6);
+ let favorite_button = gtk::Button::with_label(favorite_label(actions.favorite.active));
+ let download_button = gtk::Button::with_label("파일 다운로드...");
+ buttons.append(&favorite_button);
+ buttons.append(&download_button);
+ popover.set_child(Some(&buttons));
+
+ let toggle = actions.favorite.toggle;
+ let update_current = file.uri == current_uri;
+ let current_favorite_button = current_favorite_button.clone();
+ let popover_to_close = popover.clone();
+ favorite_button.connect_clicked(move |_| {
+ let active = toggle();
+ if update_current {
+ current_favorite_button.set_label(favorite_label(active));
+ }
+ popover_to_close.popdown();
+ });
+ let download = actions.download.download;
+ let window: gtk::Window = window.clone().upcast();
+ let status_label = status_label.clone();
+ let popover_to_close = popover.clone();
+ download_button.connect_clicked(move |_| {
+ popover_to_close.popdown();
+ download(window.clone(), status_label.clone());
+ });
+ popover.popup();
+}
+
+fn standalone_mode_index(global_index: u32) -> u32 {
+ match global_index {
+ 0 | 2 => global_index,
+ _ => 1,
}
}
@@ -869,6 +3779,58 @@ fn page_picture() -> gtk::Picture {
picture
}
+fn navigation_scale() -> gtk::Scale {
+ let scale = gtk::Scale::with_range(gtk::Orientation::Horizontal, 0.0, 1.0, 1.0);
+ scale.set_draw_value(false);
+ scale.set_hexpand(true);
+ scale.set_height_request(32);
+ scale.set_valign(gtk::Align::Center);
+ scale.set_focusable(false);
+ scale.set_margin_top(2);
+ scale.set_margin_bottom(8);
+ scale.set_margin_start(8);
+ scale.set_margin_end(8);
+ scale
+}
+
+fn navigation_message() -> (gtk::Box, gtk::Label) {
+ let message = gtk::Box::new(gtk::Orientation::Horizontal, 0);
+ message.add_css_class("osd");
+ message.set_halign(gtk::Align::Center);
+ message.set_valign(gtk::Align::Center);
+ message.set_can_target(false);
+ message.set_margin_top(12);
+ message.set_margin_bottom(12);
+ message.set_margin_start(18);
+ message.set_margin_end(18);
+ message.set_visible(false);
+ let label = gtk::Label::new(None);
+ label.add_css_class("title-2");
+ message.append(&label);
+ (message, label)
+}
+
+fn navigation_error_message(forward: bool) -> &'static str {
+ if forward {
+ "더 이상 다음 파일이 없습니다."
+ } else {
+ "더 이상 이전 파일이 없습니다."
+ }
+}
+
+fn navigation_scale_row(scale: >k::Scale) -> gtk::Box {
+ let row = gtk::Box::new(gtk::Orientation::Horizontal, 0);
+ row.set_height_request(42);
+ row.set_hexpand(true);
+ row.append(scale);
+ row.set_visible(false);
+ row
+}
+
+fn navigation_scale_upper(count: usize) -> f64 {
+ count.saturating_sub(1).max(1) as f64
+}
+
fn spread_indices(anchor: usize, count: usize) -> Vec {
if count == 0 {
return Vec::new();
@@ -885,6 +3847,166 @@ fn row_height(width: i32, ratio: f32) -> i32 {
((width as f32 / ratio).round() as i32).clamp(1, 30_000)
}
+fn single_picture_request(
+ mode: ViewMode,
+ viewport_width: i32,
+ texture_width: i32,
+ texture_height: i32,
+) -> Option<(i32, i32)> {
+ match mode {
+ ViewMode::ActualSize => Some((texture_width, texture_height)),
+ ViewMode::FitWidth => Some((
+ -1,
+ row_height(viewport_width, texture_width as f32 / texture_height as f32),
+ )),
+ _ => None,
+ }
+}
+
+fn next_image_zoom(current: f64, zoom_in: bool) -> f64 {
+ let multiplier = if zoom_in {
+ 1.0 + IMAGE_ZOOM_STEP
+ } else {
+ 1.0 - IMAGE_ZOOM_STEP
+ };
+ ((current * multiplier * 10_000.0).round() / 10_000.0).clamp(IMAGE_ZOOM_MIN, IMAGE_ZOOM_MAX)
+}
+
+fn scaled_dimension(value: i32, zoom: f64) -> i32 {
+ ((value.max(1) as f64 * zoom).round() as i32).clamp(1, 30_000)
+}
+
+fn zoomed_picture_request(
+ mode: ViewMode,
+ viewport_width: i32,
+ viewport_height: i32,
+ texture_width: i32,
+ texture_height: i32,
+ zoom: f64,
+) -> (i32, i32) {
+ let viewport_width = viewport_width.max(1);
+ let viewport_height = viewport_height.max(1);
+ let texture_width = texture_width.max(1);
+ let texture_height = texture_height.max(1);
+ let (base_width, base_height) = match mode {
+ ViewMode::ActualSize => (texture_width, texture_height),
+ ViewMode::FitWidth | ViewMode::Continuous => (
+ viewport_width,
+ row_height(viewport_width, texture_width as f32 / texture_height as f32),
+ ),
+ ViewMode::FitHeight | ViewMode::TwoPage => {
+ let scale = (viewport_width as f64 / texture_width as f64)
+ .min(viewport_height as f64 / texture_height as f64);
+ (
+ (texture_width as f64 * scale).round() as i32,
+ (texture_height as f64 * scale).round() as i32,
+ )
+ }
+ };
+ (
+ scaled_dimension(base_width, zoom.clamp(IMAGE_ZOOM_MIN, IMAGE_ZOOM_MAX)),
+ scaled_dimension(base_height, zoom.clamp(IMAGE_ZOOM_MIN, IMAGE_ZOOM_MAX)),
+ )
+}
+
+fn texture_frames(page: DecodedPage) -> (Rc, usize) {
+ let width = page.width;
+ let height = page.height;
+ let loop_count = page.loop_count;
+ let mut cost = 0;
+ let frames = page
+ .frames
+ .into_iter()
+ .map(|frame| {
+ cost += frame.rgba.len();
+ let bytes = glib::Bytes::from_owned(frame.rgba);
+ CachedFrame {
+ texture: gdk::MemoryTexture::new(
+ width as i32,
+ height as i32,
+ gdk::MemoryFormat::R8g8b8a8,
+ &bytes,
+ width as usize * 4,
+ ),
+ delay: frame.delay,
+ }
+ })
+ .collect();
+ (Rc::new(CachedAnimation { frames, loop_count }), cost)
+}
+
+fn set_picture_animation(
+ picture: >k::Picture,
+ frames: Option>,
+ state: &Rc,
+) {
+ if let Some(frames) = frames.as_ref()
+ && state
+ .frames
+ .borrow()
+ .as_ref()
+ .and_then(Weak::upgrade)
+ .is_some_and(|current| Rc::ptr_eq(¤t, frames))
+ {
+ return;
+ }
+ let current = state.cancel();
+ let Some(frames) = frames.filter(|frames| !frames.is_empty()) else {
+ picture.set_paintable(gdk::Paintable::NONE);
+ return;
+ };
+ state.frames.replace(Some(Rc::downgrade(&frames)));
+ show_animation_frame(picture.downgrade(), frames, Rc::clone(state), current, 0, 0);
+}
+
+fn show_animation_frame(
+ picture: glib::WeakRef,
+ frames: Rc,
+ state: Rc,
+ expected_generation: u64,
+ index: usize,
+ completed_loops: u32,
+) {
+ if state.generation.get() != expected_generation {
+ return;
+ }
+ let Some(picture_widget) = picture.upgrade() else {
+ return;
+ };
+ let frame = &frames[index];
+ picture_widget.set_paintable(Some(&frame.texture));
+ if frames.len() == 1 {
+ return;
+ }
+ let delay = frame.delay;
+ let next = (index + 1) % frames.len();
+ let completed_loops = completed_loops + u32::from(next == 0);
+ if next == 0
+ && frames
+ .loop_count
+ .is_some_and(|loop_count| completed_loops >= loop_count)
+ {
+ return;
+ }
+ let callback_state = Rc::clone(&state);
+ let timer = glib::timeout_add_local_once(delay, move || {
+ callback_state.timer.borrow_mut().take();
+ show_animation_frame(
+ picture,
+ frames,
+ callback_state,
+ expected_generation,
+ next,
+ completed_loops,
+ );
+ });
+ state.timer.replace(Some(timer));
+}
+
+fn continuous_content_width(stack_width: i32) -> i32 {
+ (stack_width - 24).max(320)
+}
+
fn prefetch_window(visible: &[usize], count: usize, fast: bool) -> Vec {
if visible.is_empty() || count == 0 {
return Vec::new();
@@ -918,6 +4040,157 @@ fn intersecting_rows(bounds: &[Option<(f64, f64)>], top: f64, bottom: f64) -> Ve
.collect()
}
+fn centered_scroll_value(
+ row_top: f64,
+ row_height: f64,
+ viewport_height: f64,
+ minimum: f64,
+ maximum: f64,
+) -> f64 {
+ (row_top + row_height / 2.0 - viewport_height / 2.0).clamp(minimum, maximum)
+}
+
+fn page_seek_index(value: f64, count: usize) -> Option {
+ (count > 0).then(|| (value.round().max(0.0) as usize).min(count - 1))
+}
+
+fn sibling_index(current: usize, count: usize, forward: bool) -> Option {
+ if forward {
+ (current + 1 < count).then_some(current + 1)
+ } else {
+ current.checked_sub(1)
+ }
+}
+
+fn seek_sibling_files(
+ mut files: Vec,
+ current_kind: EntryKind,
+ recursive: bool,
+) -> Vec {
+ if current_kind == EntryKind::Image && !recursive {
+ files.retain(|file| file.kind != EntryKind::ZipArchive);
+ }
+ files
+}
+
+fn filter_sibling_files(mut files: Vec, query: &str) -> Vec {
+ let query = query.to_lowercase();
+ if !query.is_empty() {
+ files.retain(|file| file.name.to_lowercase().contains(&query));
+ }
+ files
+}
+
+fn seek_position(files: &[SiblingFile], current_uri: &str) -> Option {
+ files.iter().position(|file| file.uri == current_uri)
+}
+
+fn video_seek_target(timestamp: i64, duration: i64, delta: i64) -> i64 {
+ let target = timestamp.saturating_add(delta).max(0);
+ if duration > 0 {
+ target.min(duration)
+ } else {
+ target
+ }
+}
+
+fn video_volume_target(volume: f64, delta: f64) -> f64 {
+ (volume + delta).clamp(0.0, 1.0)
+}
+
+fn video_loop_restart_needed(
+ ended: bool,
+ timestamp: i64,
+ duration: i64,
+ loop_active: bool,
+) -> bool {
+ loop_active && (ended || (duration > 0 && timestamp >= duration))
+}
+
+fn schedule_video_loop_restart(
+ stream: >k::MediaStream,
+ check: >k::CheckButton,
+ pending: &Rc>,
+) {
+ let restart_needed = video_loop_restart_needed(
+ stream.is_ended(),
+ stream.timestamp(),
+ stream.duration(),
+ check.is_active(),
+ );
+ if !begin_video_loop_restart(pending, restart_needed) {
+ return;
+ }
+ let stream = stream.clone();
+ let check = check.downgrade();
+ let pending = Rc::clone(pending);
+ glib::timeout_add_local_once(Duration::from_millis(50), move || {
+ let Some(check) = check.upgrade() else {
+ pending.set(false);
+ return;
+ };
+ if video_loop_restart_needed(
+ stream.is_ended(),
+ stream.timestamp(),
+ stream.duration(),
+ check.is_active(),
+ ) {
+ stream.pause();
+ stream.seek(0);
+ stream.play();
+ }
+ pending.set(false);
+ });
+}
+
+fn begin_video_loop_restart(pending: &Cell, restart_needed: bool) -> bool {
+ if !restart_needed {
+ pending.set(false);
+ return false;
+ }
+ !pending.replace(true)
+}
+
+fn initialize_video_volume(stream: >k::MediaStream) {
+ let volume = stream.volume().clamp(0.0, 1.0);
+ // Force the realized playback backend and GTK controls to receive the same initial value.
+ stream.set_volume(if volume > 0.0 { 0.0 } else { 1.0 });
+ stream.set_volume(volume);
+}
+
+fn pan_adjustment(adjustment: >k::Adjustment, forward: bool) -> bool {
+ let Some(value) = image_pan_target(
+ adjustment.value(),
+ adjustment.lower(),
+ adjustment.upper(),
+ adjustment.page_size(),
+ forward,
+ ) else {
+ return false;
+ };
+ adjustment.set_value(value);
+ true
+}
+
+fn image_pan_target(
+ value: f64,
+ lower: f64,
+ upper: f64,
+ page_size: f64,
+ forward: bool,
+) -> Option {
+ let maximum = (upper - page_size).max(lower);
+ if maximum <= lower {
+ return None;
+ }
+ let delta = if forward {
+ IMAGE_PAN_STEP
+ } else {
+ -IMAGE_PAN_STEP
+ };
+ Some((value + delta).clamp(lower, maximum))
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -937,6 +4210,25 @@ mod tests {
fn continuous_row_height_preserves_image_ratio() {
assert_eq!(row_height(1200, 2.0 / 3.0), 1800);
assert_eq!(row_height(1200, 1.5), 800);
+ assert_eq!(continuous_content_width(1200), 1176);
+ assert_eq!(continuous_content_width(0), 320);
+ assert_eq!(
+ single_picture_request(ViewMode::ActualSize, 1200, 800, 1600),
+ Some((800, 1600))
+ );
+ assert_eq!(
+ single_picture_request(ViewMode::FitWidth, 1200, 800, 1600),
+ Some((-1, 2400))
+ );
+ assert_eq!(
+ single_picture_request(ViewMode::FitHeight, 1200, 800, 1600),
+ None
+ );
+ assert_eq!(standalone_mode_index(0), 0);
+ assert_eq!(standalone_mode_index(1), 1);
+ assert_eq!(standalone_mode_index(2), 2);
+ assert_eq!(standalone_mode_index(3), 1);
+ assert_eq!(standalone_mode_index(4), 1);
}
#[test]
@@ -950,6 +4242,19 @@ mod tests {
assert_eq!(intersecting_rows(&bounds, 3000.0, 3800.0), [2]);
}
+ #[test]
+ fn continuous_seek_centers_the_selected_row() {
+ assert_eq!(
+ centered_scroll_value(1_000.0, 800.0, 600.0, 0.0, 5_000.0),
+ 1_100.0
+ );
+ assert_eq!(centered_scroll_value(0.0, 400.0, 800.0, 0.0, 5_000.0), 0.0);
+ assert_eq!(
+ centered_scroll_value(5_000.0, 800.0, 600.0, 0.0, 5_000.0),
+ 5_000.0
+ );
+ }
+
#[test]
fn fast_loading_prefetches_a_larger_window() {
assert_eq!(prefetch_window(&[10], 30, false), [10, 11, 12, 9]);
@@ -960,4 +4265,223 @@ mod tests {
]
);
}
+
+ #[test]
+ fn page_seek_rounds_and_clamps_to_archive() {
+ assert_eq!(page_seek_index(3.6, 10), Some(4));
+ assert_eq!(page_seek_index(20.0, 10), Some(9));
+ assert_eq!(page_seek_index(0.0, 0), None);
+ }
+
+ #[test]
+ fn navigation_scale_always_has_a_valid_range() {
+ assert_eq!(navigation_scale_upper(0), 1.0);
+ assert_eq!(navigation_scale_upper(1), 1.0);
+ assert_eq!(navigation_scale_upper(2), 1.0);
+ assert_eq!(navigation_scale_upper(10), 9.0);
+ }
+
+ #[test]
+ fn sibling_navigation_stops_at_boundaries() {
+ assert_eq!(sibling_index(1, 3, false), Some(0));
+ assert_eq!(sibling_index(1, 3, true), Some(2));
+ assert_eq!(sibling_index(0, 3, false), None);
+ assert_eq!(sibling_index(2, 3, true), None);
+ assert_eq!(SiblingTarget::First.resolve(2, 5), Some(0));
+ assert_eq!(SiblingTarget::Last.resolve(1, 5), Some(4));
+ assert_eq!(SiblingTarget::First.resolve(0, 5), None);
+ assert_eq!(SiblingTarget::Last.resolve(4, 5), None);
+ assert_eq!(SiblingTarget::Last.resolve(0, 0), None);
+ }
+
+ #[test]
+ fn video_controls_clamp_seek_and_volume() {
+ assert_eq!(video_seek_target(3_000_000, 20_000_000, -5_000_000), 0);
+ assert_eq!(
+ video_seek_target(18_000_000, 20_000_000, 5_000_000),
+ 20_000_000
+ );
+ assert_eq!(video_seek_target(18_000_000, 0, 5_000_000), 23_000_000);
+ assert_eq!(video_volume_target(0.02, -0.05), 0.0);
+ assert_eq!(video_volume_target(0.98, 0.05), 1.0);
+ assert_eq!(video_volume_target(0.5, 0.05), 0.55);
+ }
+
+ #[test]
+ fn video_loop_restarts_only_after_ending_when_enabled() {
+ assert!(video_loop_restart_needed(true, 0, 10, true));
+ assert!(video_loop_restart_needed(false, 11, 10, true));
+ assert!(!video_loop_restart_needed(false, 9, 10, true));
+ assert!(!video_loop_restart_needed(false, 11, 0, true));
+ assert!(!video_loop_restart_needed(true, 10, 10, false));
+ }
+
+ #[test]
+ fn video_loop_can_restart_more_than_once() {
+ let pending = Cell::new(false);
+ assert!(begin_video_loop_restart(&pending, true));
+ assert!(!begin_video_loop_restart(&pending, true));
+ pending.set(false);
+ assert!(begin_video_loop_restart(&pending, true));
+ assert!(!begin_video_loop_restart(&pending, false));
+ }
+
+ #[test]
+ fn image_pan_moves_at_most_100_pixels_and_consumes_clipped_axis() {
+ assert_eq!(
+ image_pan_target(250.0, 0.0, 1_000.0, 400.0, true),
+ Some(350.0)
+ );
+ assert_eq!(
+ image_pan_target(600.0, 0.0, 1_000.0, 400.0, true),
+ Some(600.0)
+ );
+ assert_eq!(image_pan_target(0.0, 0.0, 400.0, 400.0, true), None);
+ }
+
+ #[test]
+ fn viewer_file_typeahead_wraps_by_display_name() {
+ let files = ["Alpha.zip", "beta.jpg", "Bravo.mp4"].map(|name| SiblingFile {
+ uri: format!("file:///{name}"),
+ name: name.into(),
+ kind: EntryKind::Image,
+ });
+
+ assert_eq!(find_sibling_prefix(&files, "br", 0), Some(2));
+ assert_eq!(find_sibling_prefix(&files, "b", 2), Some(2));
+ assert_eq!(find_sibling_prefix(&files, "b", 3), Some(1));
+ }
+
+ #[test]
+ fn fullscreen_direction_keys_hide_controls() {
+ for key in [
+ gdk::Key::Left,
+ gdk::Key::Right,
+ gdk::Key::Up,
+ gdk::Key::Down,
+ gdk::Key::KP_Left,
+ gdk::Key::KP_Right,
+ gdk::Key::KP_Up,
+ gdk::Key::KP_Down,
+ ] {
+ assert!(fullscreen_direction_key(key));
+ }
+ assert!(!fullscreen_direction_key(gdk::Key::bracketleft));
+ assert!(!fullscreen_direction_key(gdk::Key::bracketright));
+ assert!(!fullscreen_direction_key(gdk::Key::f));
+ }
+
+ #[test]
+ fn image_zoom_changes_by_ten_percent_and_clamps() {
+ assert_eq!(next_image_zoom(1.0, true), 1.1);
+ assert_eq!(next_image_zoom(1.0, false), 0.9);
+ assert_eq!(next_image_zoom(1.1, true), 1.21);
+ assert_eq!(next_image_zoom(1.1, false), 0.99);
+ assert_eq!(next_image_zoom(IMAGE_ZOOM_MAX, true), IMAGE_ZOOM_MAX);
+ assert_eq!(next_image_zoom(IMAGE_ZOOM_MIN, false), IMAGE_ZOOM_MIN);
+ }
+
+ #[test]
+ fn ordinary_image_seek_excludes_zip_but_recursive_seek_keeps_it() {
+ let files = vec![
+ SiblingFile {
+ uri: "file:///book.zip".into(),
+ name: "book.zip".into(),
+ kind: EntryKind::ZipArchive,
+ },
+ SiblingFile {
+ uri: "file:///page.jpg".into(),
+ name: "page.jpg".into(),
+ kind: EntryKind::Image,
+ },
+ SiblingFile {
+ uri: "file:///clip.mp4".into(),
+ name: "clip.mp4".into(),
+ kind: EntryKind::Video,
+ },
+ ];
+
+ let ordinary = seek_sibling_files(files.clone(), EntryKind::Image, false);
+ assert_eq!(ordinary.len(), 2);
+ assert!(
+ !ordinary
+ .iter()
+ .any(|file| file.kind == EntryKind::ZipArchive)
+ );
+ assert_eq!(seek_position(&ordinary, "file:///page.jpg"), Some(0));
+ assert_eq!(seek_position(&ordinary, "file:///clip.mp4"), Some(1));
+ assert_eq!(seek_sibling_files(files, EntryKind::Image, true).len(), 3);
+ }
+
+ #[test]
+ fn viewer_title_includes_current_file_index() {
+ let files = ["first.zip", "second.jpg", "third.mp4"].map(|name| SiblingFile {
+ uri: format!("file:///{name}"),
+ name: name.into(),
+ kind: EntryKind::Image,
+ });
+
+ assert_eq!(
+ viewer_file_title("second.jpg", "file:///second.jpg", &files),
+ "second.jpg (2/3)"
+ );
+ assert_eq!(
+ viewer_file_title("missing.jpg", "file:///missing.jpg", &files),
+ "missing.jpg"
+ );
+ assert_eq!(
+ viewer_file_title("only.jpg", "file:///only.jpg", &[]),
+ "only.jpg"
+ );
+ }
+
+ #[test]
+ fn playlist_search_filters_and_empty_query_restores_files() {
+ let files = ["Alpha.zip", "beta.jpg", "Bravo.mp4"].map(|name| SiblingFile {
+ uri: format!("file:///{name}"),
+ name: name.into(),
+ kind: EntryKind::Image,
+ });
+
+ let filtered = filter_sibling_files(files.to_vec(), "BRAV");
+ assert_eq!(filtered.len(), 1);
+ assert_eq!(filtered[0].name, "Bravo.mp4");
+ assert_eq!(filter_sibling_files(files.to_vec(), "").len(), 3);
+ }
+
+ #[test]
+ fn file_list_shortcut_rejects_command_modifiers() {
+ assert!(!shortcut_modifiers_blocked(gdk::ModifierType::SHIFT_MASK));
+ assert!(shortcut_modifiers_blocked(gdk::ModifierType::CONTROL_MASK));
+ assert!(shortcut_modifiers_blocked(gdk::ModifierType::ALT_MASK));
+ assert!(shortcut_modifiers_blocked(gdk::ModifierType::SUPER_MASK));
+ }
+
+ #[test]
+ fn zoomed_image_request_preserves_aspect_ratio() {
+ assert_eq!(
+ zoomed_picture_request(ViewMode::ActualSize, 1000, 800, 800, 1600, 1.1),
+ (880, 1760)
+ );
+ assert_eq!(
+ zoomed_picture_request(ViewMode::FitWidth, 1000, 800, 800, 1600, 0.9),
+ (900, 1800)
+ );
+ assert_eq!(
+ zoomed_picture_request(ViewMode::FitHeight, 1000, 800, 800, 1600, 1.1),
+ (440, 880)
+ );
+ }
+
+ #[test]
+ fn navigation_boundary_messages_match_direction() {
+ assert_eq!(
+ navigation_error_message(false),
+ "더 이상 이전 파일이 없습니다."
+ );
+ assert_eq!(
+ navigation_error_message(true),
+ "더 이상 다음 파일이 없습니다."
+ );
+ }
}
diff --git a/src/window.rs b/src/window.rs
index 1d1be43..f4830f5 100644
--- a/src/window.rs
+++ b/src/window.rs
@@ -1,25 +1,48 @@
-use std::cell::RefCell;
-use std::path::PathBuf;
+use std::cell::{Cell, RefCell};
+use std::fs;
+use std::io::Read;
+use std::path::{Path, PathBuf};
+use std::process::Command;
use std::rc::Rc;
+use std::sync::mpsc;
+use std::thread;
use std::time::{Duration, Instant};
-use anyhow::Result;
+use anyhow::{Context, Result, bail};
use chrono::{DateTime, Local};
+use flate2::read::GzDecoder;
use gtk::gio;
use gtk::gio::prelude::*;
use gtk::glib;
use gtk::prelude::*;
+use sha2::{Digest, Sha256};
+use tar::Archive;
-use crate::browser::{BrowserEntry, EntryKind, SortDirection, SortField, sort_entries};
-use crate::config::{AppConfig, LocationKind, LocationProfile};
+use crate::browser::{
+ BrowserEntry, EntryKind, SortDirection, SortField, classify_file, sort_entries,
+};
+use crate::config::{
+ AppConfig, FavoriteEntry, LocationKind, LocationProfile, RecentFileEntry, ViewerMode,
+};
use crate::database::Database;
use crate::source::{
- display_remote_uri, enumerate_directory, file_from_user_input, is_within_root, mount_operation,
- parent_within_root, root_file, validate_profile,
+ display_remote_uri, ensure_mounted, enumerate_directory, enumerate_tree_entries,
+ file_from_user_input, is_within_root, mount_operation, parent_within_root, root_file,
+ validate_profile,
+};
+use crate::viewer::{
+ FavoriteControl, FileDownloadControl, FileDropControl, FileViewerControls, MediaViewerWindow,
+ SiblingFile, SiblingFileActions, SiblingNavigator, SiblingTarget, TwoPageDirectionControl,
+ ViewModeControl, ViewerWindow, install_file_drop_target, set_viewer_header, set_viewer_loading,
};
-use crate::viewer::ViewerWindow;
use crate::zip_cache::ZipCache;
+const MOUSE_BACK_BUTTON: u32 = 8;
+const RECENT_FILE_LIMIT: usize = 100;
+const UPDATE_BUNDLE_URL: &str =
+ "https://burningtuna.cafe24.com/www/Downloads/Comicviewer/Comicviewer-latest-x86_64.tar.gz";
+const UPDATE_CHECKSUM_URL: &str = "https://burningtuna.cafe24.com/www/Downloads/Comicviewer/Comicviewer-latest-x86_64.tar.gz.sha256";
+
pub struct ComicWindow {
controller: Rc,
}
@@ -43,6 +66,10 @@ impl ComicWindow {
let header = gtk::HeaderBar::new();
header.set_title_widget(Some(>k::Label::new(Some("Comicviewer"))));
+ let about_button = gtk::Button::with_label("정보");
+ header.pack_end(&about_button);
+ let clear_cache_button = gtk::Button::with_label("캐시 비우기");
+ header.pack_end(&clear_cache_button);
window.set_titlebar(Some(&header));
let root = gtk::Box::new(gtk::Orientation::Vertical, 8);
@@ -59,11 +86,14 @@ impl ComicWindow {
edit_location_button.set_sensitive(false);
let delete_location_button = gtk::Button::with_label("삭제");
delete_location_button.set_sensitive(false);
+ let clear_recent_button = gtk::Button::with_label("최근 기록 비우기");
+ clear_recent_button.set_visible(false);
locations.append(>k::Label::new(Some("위치")));
locations.append(&location_dropdown);
locations.append(&add_location_button);
locations.append(&edit_location_button);
locations.append(&delete_location_button);
+ locations.append(&clear_recent_button);
let navigation = gtk::Box::new(gtk::Orientation::Horizontal, 6);
let up_button = gtk::Button::builder()
@@ -88,6 +118,8 @@ impl ComicWindow {
.build();
let sort_dropdown = gtk::DropDown::from_strings(&["이름", "수정 시간", "생성 시간"]);
let direction_button = gtk::ToggleButton::with_label("오름차순");
+ let case_insensitive_check = gtk::CheckButton::with_label("대소문자 구분 안 함");
+ case_insensitive_check.set_active(config.case_insensitive_sort);
let fast_loading_switch = gtk::Switch::builder()
.active(config.fast_image_loading)
.tooltip_text("더 많은 페이지를 미리 디코딩하여 메모리에 유지")
@@ -95,15 +127,17 @@ impl ComicWindow {
controls.append(&search_entry);
controls.append(&sort_dropdown);
controls.append(&direction_button);
+ controls.append(&case_insensitive_check);
controls.append(>k::Label::new(Some("빠른 이미지 로딩")));
controls.append(&fast_loading_switch);
- let list_box = gtk::ListBox::new();
- list_box.set_selection_mode(gtk::SelectionMode::Single);
- list_box.set_activate_on_single_click(false);
+ let list_selection = gtk::SingleSelection::new(None::);
+ let list_view =
+ gtk::ListView::new(Some(list_selection.clone()), None::);
+ list_view.set_single_click_activate(false);
let scrolled = gtk::ScrolledWindow::builder()
.vexpand(true)
- .child(&list_box)
+ .child(&list_view)
.build();
let status_label = gtk::Label::builder().xalign(0.0).build();
@@ -116,17 +150,23 @@ impl ComicWindow {
let controller = Rc::new(BrowserController {
window,
+ about_button,
+ clear_cache_button,
location_dropdown,
edit_location_button,
delete_location_button,
+ clear_recent_button: clear_recent_button.clone(),
path_entry,
search_entry,
sort_dropdown,
direction_button,
- list_box,
+ list_view,
+ list_selection,
status_label,
state: RefCell::new(BrowserState {
profile_index: 0,
+ favorite_profile: None,
+ mode: BrowserMode::Directory,
root_uri: root_uri.clone(),
current_uri: root_uri,
entries: Vec::new(),
@@ -141,6 +181,8 @@ impl ComicWindow {
config_path,
database: Rc::new(database),
zip_cache,
+ listing_task: RefCell::new(None),
+ update_in_progress: Rc::new(Cell::new(false)),
});
controller.rebuild_profiles();
@@ -149,8 +191,10 @@ impl ComicWindow {
refresh_button,
up_button,
add_location_button,
+ case_insensitive_check,
fast_loading_switch,
);
+ install_file_drop_target(&controller.window, controller.file_drop_control());
controller.refresh();
Ok(Self { controller })
}
@@ -158,10 +202,18 @@ impl ComicWindow {
pub fn present(&self) {
self.controller.window.present();
}
+
+ pub fn open_local_items(&self, files: &[gio::File]) {
+ self.present();
+ self.controller
+ .open_dropped_files(files.to_vec(), self.controller.window.clone().upcast());
+ }
}
struct BrowserState {
profile_index: usize,
+ favorite_profile: Option,
+ mode: BrowserMode,
root_uri: String,
current_uri: String,
entries: Vec,
@@ -173,22 +225,35 @@ struct BrowserState {
typeahead_last_input: Option,
}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum BrowserMode {
+ Directory,
+ Favorites,
+ Recent,
+}
+
struct BrowserController {
window: gtk::ApplicationWindow,
+ about_button: gtk::Button,
+ clear_cache_button: gtk::Button,
location_dropdown: gtk::DropDown,
edit_location_button: gtk::Button,
delete_location_button: gtk::Button,
+ clear_recent_button: gtk::Button,
path_entry: gtk::Entry,
search_entry: gtk::SearchEntry,
sort_dropdown: gtk::DropDown,
direction_button: gtk::ToggleButton,
- list_box: gtk::ListBox,
+ list_view: gtk::ListView,
+ list_selection: gtk::SingleSelection,
status_label: gtk::Label,
state: RefCell,
config: RefCell,
config_path: PathBuf,
database: Rc,
zip_cache: Rc,
+ listing_task: RefCell>>,
+ update_in_progress: Rc>,
}
impl BrowserController {
@@ -198,6 +263,7 @@ impl BrowserController {
refresh_button: gtk::Button,
up_button: gtk::Button,
add_location_button: gtk::Button,
+ case_insensitive_check: gtk::CheckButton,
fast_loading_switch: gtk::Switch,
) {
let controller = Rc::clone(self);
@@ -212,6 +278,9 @@ impl BrowserController {
let controller = Rc::clone(self);
add_location_button.connect_clicked(move |_| controller.show_location_dialog(None));
let controller = Rc::clone(self);
+ self.about_button
+ .connect_clicked(move |_| controller.show_about_dialog());
+ let controller = Rc::clone(self);
self.edit_location_button.connect_clicked(move |_| {
if let Some(index) = controller.selected_config_index() {
controller.show_location_dialog(Some(index));
@@ -226,6 +295,46 @@ impl BrowserController {
let controller = Rc::clone(self);
self.location_dropdown
.connect_selected_notify(move |_| controller.select_profile());
+ let location_factory = gtk::SignalListItemFactory::new();
+ let controller = Rc::downgrade(self);
+ location_factory.connect_setup(move |_, item| {
+ let Some(item) = item.downcast_ref::() else {
+ return;
+ };
+ let label = gtk::Label::builder().xalign(0.0).build();
+ let click = gtk::GestureClick::builder().button(1).build();
+ item.set_child(Some(&label));
+ let item = item.downgrade();
+ let controller = controller.clone();
+ click.connect_released(move |_, _, _, _| {
+ let Some(item) = item.upgrade() else {
+ return;
+ };
+ let Some(controller) = controller.upgrade() else {
+ return;
+ };
+ match special_browser_mode(item.position(), controller.profiles().len()) {
+ Some(BrowserMode::Favorites) => controller.show_favorites(),
+ Some(BrowserMode::Recent) => controller.show_recent(),
+ _ => {}
+ }
+ });
+ label.add_controller(click);
+ });
+ location_factory.connect_bind(|_, item| {
+ let Some(item) = item.downcast_ref::() else {
+ return;
+ };
+ let Some(label) = item.child().and_downcast::() else {
+ return;
+ };
+ let Some(value) = item.item().and_downcast::() else {
+ return;
+ };
+ label.set_text(value.string().as_str());
+ });
+ self.location_dropdown
+ .set_list_factory(Some(&location_factory));
let controller = Rc::clone(self);
self.search_entry
.connect_search_changed(move |_| controller.render());
@@ -236,19 +345,87 @@ impl BrowserController {
self.direction_button
.connect_toggled(move |_| controller.change_sort_direction());
let controller = Rc::clone(self);
- self.list_box
- .connect_row_activated(move |_, row| controller.activate_row(row.index()));
+ case_insensitive_check.connect_toggled(move |check| {
+ controller.set_case_insensitive_sort(check);
+ });
+ let factory = gtk::SignalListItemFactory::new();
+ let controller = Rc::downgrade(self);
+ factory.connect_setup(move |_, item| {
+ let Some(item) = item.downcast_ref::() else {
+ return;
+ };
+ let content = entry_content();
+ item.set_child(Some(&content));
+ let context_click = gtk::GestureClick::builder().button(3).build();
+ let item = item.downgrade();
+ let controller = controller.clone();
+ let menu_parent = content.clone();
+ context_click.connect_pressed(move |_, _, _, _| {
+ let Some(item) = item.upgrade() else {
+ return;
+ };
+ let Some(controller) = controller.upgrade() else {
+ return;
+ };
+ controller.show_context_menu(item.position(), &menu_parent);
+ });
+ content.add_controller(context_click);
+ });
+ let controller = Rc::downgrade(self);
+ factory.connect_bind(move |_, item| {
+ let Some(item) = item.downcast_ref::() else {
+ return;
+ };
+ let Some(content) = item.child().and_downcast::() else {
+ return;
+ };
+ let Some(controller) = controller.upgrade() else {
+ return;
+ };
+ let state = controller.state.borrow();
+ let Some(entry) = state.visible_entries.get(item.position() as usize) else {
+ return;
+ };
+ bind_entry_content(&content, entry);
+ });
+ self.list_view.set_factory(Some(&factory));
+ let controller = Rc::clone(self);
+ self.list_view
+ .connect_activate(move |_, position| controller.activate_row(position));
let key_controller = gtk::EventControllerKey::new();
let controller = Rc::clone(self);
- key_controller
- .connect_key_pressed(move |_, key, _, modifiers| controller.typeahead(key, modifiers));
- self.list_box.add_controller(key_controller);
+ key_controller.connect_key_pressed(move |_, key, _, modifiers| {
+ if key == gtk::gdk::Key::BackSpace && !controller.typeahead_is_active() {
+ controller.go_up();
+ glib::Propagation::Stop
+ } else {
+ controller.typeahead(key, modifiers)
+ }
+ });
+ self.list_view.add_controller(key_controller);
+
+ let mouse_back = gtk::GestureClick::builder()
+ .button(MOUSE_BACK_BUTTON)
+ .propagation_phase(gtk::PropagationPhase::Capture)
+ .build();
+ let controller = Rc::clone(self);
+ mouse_back.connect_pressed(move |gesture, _, _, _| {
+ gesture.set_state(gtk::EventSequenceState::Claimed);
+ controller.go_up();
+ });
+ self.window.add_controller(mouse_back);
let controller = Rc::clone(self);
fast_loading_switch.connect_active_notify(move |switch| {
controller.set_fast_image_loading(switch);
});
+ let controller = Rc::clone(self);
+ self.clear_cache_button
+ .connect_clicked(move |_| controller.show_clear_cache_dialog());
+ let controller = Rc::clone(self);
+ self.clear_recent_button
+ .connect_clicked(move |_| controller.show_clear_recent_dialog());
}
fn profiles(&self) -> Vec {
@@ -257,22 +434,46 @@ impl BrowserController {
profiles
}
+ fn current_profile(&self) -> LocationProfile {
+ let state = self.state.borrow();
+ state.favorite_profile.clone().unwrap_or_else(|| {
+ self.profiles()
+ .get(state.profile_index)
+ .cloned()
+ .unwrap_or_else(home_profile)
+ })
+ }
+
fn rebuild_profiles(&self) {
let profiles = self.profiles();
- let names: Vec<_> = profiles
+ let mut names: Vec<_> = profiles
.iter()
- .map(|profile| profile.name.as_str())
+ .map(|profile| profile.name.clone())
.collect();
+ names.push("즐겨찾기".into());
+ names.push("최근 열어본 파일".into());
+ let names: Vec<_> = names.iter().map(String::as_str).collect();
self.location_dropdown
.set_model(Some(>k::StringList::new(&names)));
}
fn select_profile(self: &Rc) {
let profile_index = self.location_dropdown.selected() as usize;
- let editable = profile_index > 0 && profile_index <= self.config.borrow().locations.len();
+ let profiles = self.profiles();
+ match special_browser_mode(self.location_dropdown.selected(), profiles.len()) {
+ Some(BrowserMode::Favorites) => {
+ self.show_favorites();
+ return;
+ }
+ Some(BrowserMode::Recent) => {
+ self.show_recent();
+ return;
+ }
+ _ => {}
+ }
+ let editable = profile_index > 0 && profile_index < profiles.len();
self.edit_location_button.set_sensitive(editable);
self.delete_location_button.set_sensitive(editable);
- let profiles = self.profiles();
let Some(profile) = profiles.get(profile_index) else {
return;
};
@@ -281,9 +482,13 @@ impl BrowserController {
let root_uri: String = root.uri().into();
let mut state = self.state.borrow_mut();
state.profile_index = profile_index;
+ state.favorite_profile = None;
+ state.mode = BrowserMode::Directory;
state.root_uri = root_uri.clone();
state.current_uri = root_uri;
drop(state);
+ self.update_mode_controls(BrowserMode::Directory);
+ self.path_entry.set_editable(true);
self.search_entry.set_text("");
self.refresh();
}
@@ -291,8 +496,169 @@ impl BrowserController {
}
}
+ fn show_favorites(&self) {
+ self.cancel_listing();
+ self.edit_location_button.set_sensitive(false);
+ self.delete_location_button.set_sensitive(false);
+ self.path_entry.set_text("즐겨찾기");
+ self.path_entry.set_editable(false);
+ let entries = self
+ .config
+ .borrow()
+ .favorites
+ .iter()
+ .map(favorite_browser_entry)
+ .collect();
+ let mut state = self.state.borrow_mut();
+ state.generation = state.generation.wrapping_add(1);
+ state.typeahead_query.clear();
+ state.typeahead_last_input = None;
+ state.mode = BrowserMode::Favorites;
+ state.favorite_profile = None;
+ state.entries = entries;
+ drop(state);
+ self.update_mode_controls(BrowserMode::Favorites);
+ self.search_entry.set_text("");
+ self.render();
+ }
+
+ fn show_recent(&self) {
+ self.cancel_listing();
+ self.edit_location_button.set_sensitive(false);
+ self.delete_location_button.set_sensitive(false);
+ self.path_entry.set_text("최근 열어본 파일");
+ self.path_entry.set_editable(false);
+ let entries = self
+ .config
+ .borrow()
+ .recent_files
+ .iter()
+ .map(recent_file_browser_entry)
+ .collect();
+ let mut state = self.state.borrow_mut();
+ state.generation = state.generation.wrapping_add(1);
+ state.typeahead_query.clear();
+ state.typeahead_last_input = None;
+ state.mode = BrowserMode::Recent;
+ state.favorite_profile = None;
+ state.entries = entries;
+ drop(state);
+ self.update_mode_controls(BrowserMode::Recent);
+ self.search_entry.set_text("");
+ self.render();
+ }
+
+ fn update_mode_controls(&self, mode: BrowserMode) {
+ let recent = mode == BrowserMode::Recent;
+ self.clear_recent_button.set_visible(recent);
+ self.sort_dropdown.set_sensitive(!recent);
+ self.direction_button.set_sensitive(!recent);
+ }
+
+ fn open_favorite(self: &Rc, favorite: FavoriteEntry) {
+ let Ok(root) = root_file(&favorite.profile) else {
+ self.status_label
+ .set_text("저장된 파일의 위치 정보가 올바르지 않습니다.");
+ return;
+ };
+ let favorite_file = gio::File::for_uri(&favorite.uri);
+ if !is_within_root(&favorite_file, &root) {
+ self.status_label
+ .set_text("저장된 파일이 위치의 루트 밖을 가리킵니다.");
+ return;
+ }
+ if favorite.is_directory {
+ self.location_dropdown
+ .set_selected(gtk::INVALID_LIST_POSITION);
+ self.edit_location_button.set_sensitive(false);
+ self.delete_location_button.set_sensitive(false);
+ let mut state = self.state.borrow_mut();
+ state.favorite_profile = Some(favorite.profile.clone());
+ state.mode = BrowserMode::Directory;
+ state.root_uri = root.uri().into();
+ state.current_uri = favorite.uri;
+ drop(state);
+ self.update_mode_controls(BrowserMode::Directory);
+ self.search_entry.set_text("");
+ self.refresh();
+ return;
+ }
+
+ self.cancel_listing();
+ self.status_label.set_text("저장된 파일에 연결하는 중...");
+ let operation = mount_operation(&favorite.profile, &self.window);
+ let controller = Rc::downgrade(self);
+ let task = glib::MainContext::default().spawn_local(async move {
+ let file = gio::File::for_uri(&favorite.uri);
+ let result = ensure_mounted(&file, &favorite.profile, &operation).await;
+ let folder_entries = if result.is_ok() {
+ if let Some(parent) = file.parent() {
+ enumerate_directory(
+ &favorite.profile,
+ parent.uri().as_str(),
+ &operation,
+ |_| {},
+ )
+ .await
+ .ok()
+ } else {
+ None
+ }
+ } else {
+ None
+ };
+ let Some(controller) = controller.upgrade() else {
+ return;
+ };
+ if let Err(error) = result {
+ controller.status_label.set_text(&format!("{error:#}"));
+ return;
+ }
+ let kind = classify_file(Path::new(&favorite.name));
+ if !kind.is_viewable() {
+ controller
+ .status_label
+ .set_text("이 파일 형식은 열 수 없습니다.");
+ return;
+ }
+ let entry = folder_entries
+ .as_ref()
+ .and_then(|entries| entries.iter().find(|entry| entry.uri == favorite.uri))
+ .cloned()
+ .unwrap_or_else(|| BrowserEntry {
+ uri: favorite.uri.clone(),
+ name: favorite.name.clone(),
+ list_name: None,
+ kind,
+ size: None,
+ modified: None,
+ created: None,
+ etag: None,
+ });
+ let siblings = folder_entries.map_or_else(
+ || vec![entry.clone()],
+ |entries| {
+ let state = controller.state.borrow();
+ sorted_navigable_entries(
+ &entries,
+ kind,
+ state.sort_field,
+ state.sort_direction,
+ controller.config.borrow().case_insensitive_sort,
+ )
+ },
+ );
+ let siblings = Rc::new(siblings);
+ controller.open_viewable(entry, siblings, favorite.profile, None);
+ });
+ self.listing_task.replace(Some(task));
+ }
+
fn open_entered_path(self: &Rc) {
- let profile = self.profiles()[self.state.borrow().profile_index].clone();
+ if self.state.borrow().mode != BrowserMode::Directory {
+ return;
+ }
+ let profile = self.current_profile();
let entered = self.path_entry.text();
let file = file_from_user_input(profile.kind, entered.as_str());
let root = gio::File::for_uri(&self.state.borrow().root_uri);
@@ -306,6 +672,9 @@ impl BrowserController {
}
fn go_up(self: &Rc) {
+ if self.state.borrow().mode != BrowserMode::Directory {
+ return;
+ }
let state = self.state.borrow();
let current = gio::File::for_uri(&state.current_uri);
let root = gio::File::for_uri(&state.root_uri);
@@ -317,29 +686,49 @@ impl BrowserController {
}
fn refresh(self: &Rc) {
+ let mode = self.state.borrow().mode;
+ match mode {
+ BrowserMode::Favorites => {
+ self.show_favorites();
+ return;
+ }
+ BrowserMode::Recent => {
+ self.show_recent();
+ return;
+ }
+ BrowserMode::Directory => {}
+ }
+ self.cancel_listing();
let (profile, uri, generation) = {
let mut state = self.state.borrow_mut();
state.generation = state.generation.wrapping_add(1);
state.typeahead_query.clear();
state.typeahead_last_input = None;
+ state.entries.clear();
+ state.visible_entries.clear();
(
- self.profiles()[state.profile_index].clone(),
+ state
+ .favorite_profile
+ .clone()
+ .unwrap_or_else(|| self.profiles()[state.profile_index].clone()),
state.current_uri.clone(),
state.generation,
)
};
+ self.list_selection.set_model(None::<&gio::ListModel>);
self.path_entry.set_text(&display_uri(&uri));
self.status_label
.set_text("폴더를 불러오는 중... (0개의 파일/폴더를 읽음)");
let operation = mount_operation(&profile, &self.window);
let progress_controller = Rc::downgrade(self);
let controller = Rc::downgrade(self);
- glib::MainContext::default().spawn_local(async move {
+ let task = glib::MainContext::default().spawn_local(async move {
let result = enumerate_directory(&profile, &uri, &operation, move |count| {
let Some(controller) = progress_controller.upgrade() else {
return;
};
- if controller.state.borrow().generation == generation {
+ let state = controller.state.borrow();
+ if state.generation == generation && state.mode == BrowserMode::Directory {
controller.status_label.set_text(&format!(
"폴더를 불러오는 중... ({count}개의 파일/폴더를 읽음)"
));
@@ -349,7 +738,10 @@ impl BrowserController {
let Some(controller) = controller.upgrade() else {
return;
};
- if controller.state.borrow().generation != generation {
+ let state = controller.state.borrow();
+ let stale = state.generation != generation || state.mode != BrowserMode::Directory;
+ drop(state);
+ if stale {
return;
}
match result {
@@ -360,26 +752,42 @@ impl BrowserController {
Err(error) => controller.status_label.set_text(&format!("{error:#}")),
}
});
+ self.listing_task.replace(Some(task));
+ }
+
+ fn cancel_listing(&self) {
+ if let Some(task) = self.listing_task.borrow_mut().take() {
+ task.abort();
+ }
}
fn render(&self) {
- while let Some(child) = self.list_box.first_child() {
- self.list_box.remove(&child);
- }
let query = self.search_entry.text().to_lowercase();
+ let case_insensitive = self.config.borrow().case_insensitive_sort;
let mut state = self.state.borrow_mut();
let mut visible_entries: Vec<_> = state
.entries
.iter()
- .filter(|entry| entry.name.to_lowercase().contains(query.as_str()))
+ .filter(|entry| browser_search_match(entry, query.as_str()))
.cloned()
.collect();
- sort_entries(&mut visible_entries, state.sort_field, state.sort_direction);
- for entry in &visible_entries {
- self.list_box.append(&entry_row(entry));
+ if state.mode != BrowserMode::Recent {
+ sort_entries(
+ &mut visible_entries,
+ state.sort_field,
+ state.sort_direction,
+ case_insensitive,
+ );
}
let count = visible_entries.len();
+ let names = visible_entries
+ .iter()
+ .map(BrowserEntry::display_name)
+ .collect::>();
+ let model = gtk::StringList::new(&names);
state.visible_entries = visible_entries;
+ drop(state);
+ self.list_selection.set_model(Some(&model));
self.status_label.set_text(&format!("{count}개 항목"));
}
@@ -394,14 +802,26 @@ impl BrowserController {
if modifiers.intersects(blocked) {
return glib::Propagation::Proceed;
}
- let Some(character) = key
- .to_unicode()
- .filter(|character| character.is_alphanumeric())
- else {
+ if key == gtk::gdk::Key::Escape {
+ let mut state = self.state.borrow_mut();
+ state.typeahead_query.clear();
+ state.typeahead_last_input = None;
+ return glib::Propagation::Stop;
+ }
+ if key == gtk::gdk::Key::BackSpace {
+ let mut state = self.state.borrow_mut();
+ if state.typeahead_query.pop().is_none() {
+ return glib::Propagation::Proceed;
+ }
+ state.typeahead_last_input = Some(Instant::now());
+ return glib::Propagation::Stop;
+ }
+ let Some(character) = key.to_unicode().filter(|character| !character.is_control()) else {
return glib::Propagation::Proceed;
};
- let selected = self.list_box.selected_row().map(|row| row.index() as usize);
+ let selected = (self.list_selection.selected() != gtk::INVALID_LIST_POSITION)
+ .then(|| self.list_selection.selected() as usize);
let now = Instant::now();
let mut state = self.state.borrow_mut();
if state
@@ -424,14 +844,15 @@ impl BrowserController {
0
};
let found = find_prefix_index(&state.visible_entries, &query, start);
- let found_name = found.map(|index| state.visible_entries[index].name.clone());
+ let found_name = found.map(|index| state.visible_entries[index].display_name().to_owned());
drop(state);
- if let Some(index) = found
- && let Some(row) = self.list_box.row_at_index(index as i32)
- {
- self.list_box.select_row(Some(&row));
- let _ = row.grab_focus();
+ if let Some(index) = found {
+ self.list_view.scroll_to(
+ index as u32,
+ gtk::ListScrollFlags::FOCUS | gtk::ListScrollFlags::SELECT,
+ None,
+ );
self.status_label.set_text(&format!(
"'{query}'로 이동: {}",
found_name.unwrap_or_default()
@@ -443,6 +864,14 @@ impl BrowserController {
glib::Propagation::Stop
}
+ fn typeahead_is_active(&self) -> bool {
+ let state = self.state.borrow();
+ !state.typeahead_query.is_empty()
+ && state.typeahead_last_input.is_some_and(|last| {
+ Instant::now().duration_since(last) <= Duration::from_millis(1200)
+ })
+ }
+
fn change_sort_field(&self) {
self.state.borrow_mut().sort_field = match self.sort_dropdown.selected() {
1 => SortField::Modified,
@@ -464,7 +893,7 @@ impl BrowserController {
self.render();
}
- fn activate_row(self: &Rc, index: i32) {
+ fn activate_row(self: &Rc, index: u32) {
let Some(entry) = self
.state
.borrow()
@@ -474,44 +903,869 @@ impl BrowserController {
else {
return;
};
+ let mode = self.state.borrow().mode;
+ match mode {
+ BrowserMode::Favorites => {
+ let favorite = self
+ .config
+ .borrow()
+ .favorites
+ .iter()
+ .find(|favorite| favorite.uri == entry.uri)
+ .cloned();
+ if let Some(favorite) = favorite {
+ self.open_favorite(favorite);
+ }
+ return;
+ }
+ BrowserMode::Recent => {
+ let recent = self
+ .config
+ .borrow()
+ .recent_files
+ .iter()
+ .find(|recent| recent.uri == entry.uri)
+ .cloned();
+ if let Some(recent) = recent {
+ self.open_favorite(FavoriteEntry {
+ name: recent.name,
+ uri: recent.uri,
+ is_directory: false,
+ profile: recent.profile,
+ });
+ }
+ return;
+ }
+ BrowserMode::Directory => {}
+ }
match entry.kind {
EntryKind::Directory => {
self.state.borrow_mut().current_uri = entry.uri;
self.search_entry.set_text("");
self.refresh();
}
- EntryKind::ZipArchive => self.open_archive(entry),
+ EntryKind::ZipArchive | EntryKind::Image | EntryKind::Video => {
+ let current_kind = entry.kind;
+ let case_insensitive = self.config.borrow().case_insensitive_sort;
+ let siblings = {
+ let state = self.state.borrow();
+ sorted_navigable_entries(
+ &state.entries,
+ current_kind,
+ state.sort_field,
+ state.sort_direction,
+ case_insensitive,
+ )
+ };
+ let siblings = Rc::new(siblings);
+ if siblings.iter().any(|item| item.uri == entry.uri) {
+ self.open_viewable(entry, siblings, self.current_profile(), None);
+ }
+ }
+ EntryKind::OtherFile => {}
}
}
- fn open_archive(self: &Rc, entry: BrowserEntry) {
+ fn open_viewable(
+ self: &Rc,
+ entry: BrowserEntry,
+ siblings: Rc>,
+ profile: LocationProfile,
+ reuse_window: Option,
+ ) {
+ match entry.kind {
+ EntryKind::ZipArchive => self.open_archive(entry, siblings, profile, reuse_window),
+ EntryKind::Image | EntryKind::Video => {
+ self.open_media(entry, siblings, profile, reuse_window)
+ }
+ _ => {}
+ }
+ }
+
+ fn sibling_navigator(
+ self: &Rc,
+ entry: &BrowserEntry,
+ siblings: Rc>,
+ profile: LocationProfile,
+ ) -> SiblingNavigator {
+ let recursive = siblings.iter().any(|entry| entry.list_name.is_some());
+ let current_uri = entry.uri.clone();
+ let current_kind = entry.kind;
+ let controller = Rc::downgrade(self);
+ let navigate_siblings = Rc::clone(&siblings);
+ let navigate_current_uri = current_uri.clone();
+ let navigate_profile = profile.clone();
+ let navigate = Rc::new(
+ move |target: SiblingTarget, reuse_window: gtk::ApplicationWindow| {
+ let Some(controller) = controller.upgrade() else {
+ return false;
+ };
+ let siblings = controller.navigation_siblings(
+ &navigate_current_uri,
+ current_kind,
+ &navigate_siblings,
+ recursive,
+ );
+ let Some(current) = siblings
+ .iter()
+ .position(|entry| entry.uri == navigate_current_uri)
+ else {
+ return false;
+ };
+ let Some(next) = target.resolve(current, siblings.len()) else {
+ return false;
+ };
+ controller.open_viewable(
+ siblings[next].clone(),
+ Rc::clone(&siblings),
+ navigate_profile.clone(),
+ Some(reuse_window),
+ );
+ true
+ },
+ );
+ let files_controller = Rc::downgrade(self);
+ let files_current_uri = current_uri.clone();
+ let files_fallback = Rc::clone(&siblings);
+ let files = Rc::new(move || {
+ let Some(controller) = files_controller.upgrade() else {
+ return Vec::new();
+ };
+ controller
+ .navigation_siblings(&files_current_uri, current_kind, &files_fallback, recursive)
+ .iter()
+ .map(|entry| SiblingFile {
+ uri: entry.uri.clone(),
+ name: entry.display_name().to_owned(),
+ kind: entry.kind,
+ })
+ .collect()
+ });
+ let actions_controller = Rc::downgrade(self);
+ let actions_current_uri = current_uri;
+ let actions_fallback = Rc::clone(&siblings);
+ let actions_profile = profile;
+ let actions = Rc::new(move |uri: &str| {
+ let controller = actions_controller.upgrade()?;
+ let entries = controller.navigation_siblings(
+ &actions_current_uri,
+ current_kind,
+ &actions_fallback,
+ recursive,
+ );
+ let entry = entries.iter().find(|entry| entry.uri == uri)?;
+ Some(SiblingFileActions {
+ favorite: controller.favorite_control(entry, &actions_profile),
+ download: controller.download_control(entry),
+ })
+ });
+ SiblingNavigator::new(navigate, files, actions, recursive)
+ }
+
+ fn navigation_siblings(
+ &self,
+ current_uri: &str,
+ current_kind: EntryKind,
+ fallback: &Rc>,
+ fixed: bool,
+ ) -> Rc> {
+ if fixed {
+ return Rc::clone(fallback);
+ }
+ let case_insensitive = self.config.borrow().case_insensitive_sort;
+ let state = self.state.borrow();
+ let entries = sorted_navigable_entries(
+ &state.entries,
+ current_kind,
+ state.sort_field,
+ state.sort_direction,
+ case_insensitive,
+ );
+ let mode = state.mode;
+ drop(state);
+ if mode == BrowserMode::Directory && entries.iter().any(|entry| entry.uri == current_uri) {
+ Rc::new(entries)
+ } else {
+ Rc::clone(fallback)
+ }
+ }
+
+ fn open_archive(
+ self: &Rc,
+ entry: BrowserEntry,
+ siblings: Rc>,
+ profile: LocationProfile,
+ reuse_window: Option,
+ ) {
+ let recent_entry = entry.clone();
+ let recent_profile = profile.clone();
self.status_label.set_text("ZIP 파일 다운로드 준비 중...");
- let progress_label = self.status_label.clone();
+ let progress_label = reuse_window.as_ref().map_or_else(
+ || self.status_label.clone(),
+ |window| show_viewer_loading(window, &entry.name, "ZIP 파일을 준비하는 중..."),
+ );
+ let result_label = progress_label.clone();
let controller = Rc::clone(self);
+ let navigator = self.sibling_navigator(&entry, siblings, profile.clone());
+ let favorite_control = self.favorite_control(&entry, &profile);
+ let download_control = self.download_control(&entry);
+ let view_mode_control = self.view_mode_control();
self.zip_cache.prepare(
entry,
move |current, total| {
let percent = if total > 0 { current * 100 / total } else { 0 };
progress_label.set_text(&format!("ZIP 다운로드 중... {percent}%"));
},
- move |result| match result {
- Ok(source) => {
- controller.status_label.set_text("다운로드 완료");
- let Some(application) = controller.window.application() else {
- return;
- };
- ViewerWindow::open(
- &application,
- source,
- Rc::clone(&controller.database),
- controller.config.borrow().fast_image_loading,
- );
+ move |result| {
+ if reuse_window
+ .as_ref()
+ .is_some_and(|window| !window.is_visible())
+ {
+ return;
+ }
+ match result {
+ Ok(source) => {
+ controller.record_recent_file(&recent_entry, &recent_profile);
+ controller.status_label.set_text("다운로드 완료");
+ result_label.set_text("ZIP 파일을 여는 중...");
+ let Some(application) = controller.window.application() else {
+ return;
+ };
+ let direction_control = controller.two_page_direction_control();
+ ViewerWindow::open(
+ &application,
+ source,
+ Rc::clone(&controller.database),
+ controller.config.borrow().fast_image_loading,
+ controller.config.borrow().case_insensitive_sort,
+ view_mode_control,
+ FileViewerControls {
+ sibling_navigator: Some(navigator),
+ favorite_control,
+ download_control,
+ file_drop_control: controller.file_drop_control(),
+ reuse_window,
+ view_mode_control: None,
+ two_page_direction_control: Some(direction_control),
+ },
+ );
+ }
+ Err(error) => {
+ let message = format!("{error:#}");
+ controller.status_label.set_text(&message);
+ result_label.set_text(&message);
+ }
}
- Err(error) => controller.status_label.set_text(&format!("{error:#}")),
},
);
}
+ fn open_media(
+ self: &Rc,
+ entry: BrowserEntry,
+ siblings: Rc>,
+ profile: LocationProfile,
+ reuse_window: Option,
+ ) {
+ let recent_entry = entry.clone();
+ let recent_profile = profile.clone();
+ let kind = entry.kind;
+ self.status_label
+ .set_text("미디어 파일 다운로드 준비 중...");
+ let progress_label = reuse_window.as_ref().map_or_else(
+ || self.status_label.clone(),
+ |window| show_viewer_loading(window, &entry.name, "미디어 파일을 준비하는 중..."),
+ );
+ let result_label = progress_label.clone();
+ let controller = Rc::clone(self);
+ let navigator = self.sibling_navigator(&entry, siblings, profile.clone());
+ let favorite_control = self.favorite_control(&entry, &profile);
+ let download_control = self.download_control(&entry);
+ let view_mode_control = (kind == EntryKind::Image).then(|| self.view_mode_control());
+ self.zip_cache.prepare_media(
+ entry,
+ move |current, total| {
+ let percent = if total > 0 { current * 100 / total } else { 0 };
+ progress_label.set_text(&format!("미디어 다운로드 중... {percent}%"));
+ },
+ move |result| {
+ if reuse_window
+ .as_ref()
+ .is_some_and(|window| !window.is_visible())
+ {
+ return;
+ }
+ match result {
+ Ok(source) => {
+ controller.record_recent_file(&recent_entry, &recent_profile);
+ controller.status_label.set_text("다운로드 완료");
+ result_label.set_text("미디어 파일을 여는 중...");
+ let Some(application) = controller.window.application() else {
+ return;
+ };
+ MediaViewerWindow::open(
+ &application,
+ source,
+ kind,
+ FileViewerControls {
+ sibling_navigator: Some(navigator),
+ favorite_control,
+ download_control,
+ file_drop_control: controller.file_drop_control(),
+ reuse_window,
+ view_mode_control,
+ two_page_direction_control: None,
+ },
+ );
+ }
+ Err(error) => {
+ let message = format!("{error:#}");
+ controller.status_label.set_text(&message);
+ result_label.set_text(&message);
+ }
+ }
+ },
+ );
+ }
+
+ fn show_context_menu(
+ self: &Rc,
+ position: u32,
+ parent: &impl glib::object::IsA,
+ ) {
+ let Some(entry) = self
+ .state
+ .borrow()
+ .visible_entries
+ .get(position as usize)
+ .cloned()
+ else {
+ return;
+ };
+ let can_favorite = entry.kind == EntryKind::Directory || entry.kind.is_viewable();
+ let can_download = entry.kind != EntryKind::Directory;
+ if !can_favorite && !can_download {
+ return;
+ }
+ self.list_selection.set_selected(position);
+ let popover = gtk::Popover::new();
+ popover.set_parent(parent);
+ let actions = gtk::Box::new(gtk::Orientation::Vertical, 4);
+ actions.set_margin_top(6);
+ actions.set_margin_bottom(6);
+ actions.set_margin_start(6);
+ actions.set_margin_end(6);
+ if entry.kind == EntryKind::Directory {
+ let open_folder_button = gtk::Button::with_label("폴더 열기");
+ actions.append(&open_folder_button);
+ let controller = Rc::clone(self);
+ let popover_to_close = popover.clone();
+ let folder_entry = entry.clone();
+ open_folder_button.connect_clicked(move |_| {
+ popover_to_close.popdown();
+ controller.open_folder_recursive(folder_entry.clone());
+ });
+ }
+ if can_favorite {
+ let is_favorite = self.is_favorite(&entry.uri);
+ let favorite_button = gtk::Button::with_label(if is_favorite {
+ "즐겨찾기 제거"
+ } else {
+ "즐겨찾기 추가"
+ });
+ actions.append(&favorite_button);
+ let controller = Rc::clone(self);
+ let popover_to_close = popover.clone();
+ let favorite_entry = entry.clone();
+ favorite_button.connect_clicked(move |_| {
+ popover_to_close.popdown();
+ let profile = controller.profile_for_entry(&favorite_entry);
+ controller.toggle_favorite(&favorite_entry, &profile);
+ });
+ }
+ if can_download {
+ let download_button = gtk::Button::with_label("파일 다운로드...");
+ actions.append(&download_button);
+ let controller = Rc::clone(self);
+ let popover_to_close = popover.clone();
+ download_button.connect_clicked(move |_| {
+ popover_to_close.popdown();
+ controller.choose_download_destination(
+ entry.clone(),
+ controller.window.clone().upcast(),
+ controller.status_label.clone(),
+ );
+ });
+ }
+ popover.set_child(Some(&actions));
+ popover.popup();
+ }
+
+ fn is_favorite(&self, uri: &str) -> bool {
+ self.config
+ .borrow()
+ .favorites
+ .iter()
+ .any(|favorite| favorite.uri == uri)
+ }
+
+ fn profile_for_entry(&self, entry: &BrowserEntry) -> LocationProfile {
+ match self.state.borrow().mode {
+ BrowserMode::Favorites => {
+ if let Some(profile) = self
+ .config
+ .borrow()
+ .favorites
+ .iter()
+ .find(|favorite| favorite.uri == entry.uri)
+ .map(|favorite| favorite.profile.clone())
+ {
+ return profile;
+ }
+ }
+ BrowserMode::Recent => {
+ if let Some(profile) = self
+ .config
+ .borrow()
+ .recent_files
+ .iter()
+ .find(|recent| recent.uri == entry.uri)
+ .map(|recent| recent.profile.clone())
+ {
+ return profile;
+ }
+ }
+ BrowserMode::Directory => {}
+ }
+ self.current_profile()
+ }
+
+ fn open_folder_recursive(self: &Rc, entry: BrowserEntry) {
+ let profile = self.profile_for_entry(&entry);
+ let Ok(profile_root) = root_file(&profile) else {
+ self.status_label
+ .set_text("폴더의 저장된 위치 정보를 확인할 수 없습니다.");
+ return;
+ };
+ let folder = gio::File::for_uri(&entry.uri);
+ if !is_within_root(&folder, &profile_root) {
+ self.status_label
+ .set_text("저장된 위치의 루트 아래 폴더만 열 수 있습니다.");
+ return;
+ }
+ self.cancel_listing();
+ let (generation, sort_field, sort_direction) = {
+ let mut state = self.state.borrow_mut();
+ state.generation = state.generation.wrapping_add(1);
+ (state.generation, state.sort_field, state.sort_direction)
+ };
+ let case_insensitive = self.config.borrow().case_insensitive_sort;
+ self.status_label
+ .set_text("하위 폴더에서 열 수 있는 파일을 찾는 중...");
+ let operation = mount_operation(&profile, &self.window);
+ let progress_controller = Rc::downgrade(self);
+ let controller = Rc::downgrade(self);
+ let task = glib::MainContext::default().spawn_local(async move {
+ let result =
+ enumerate_tree_entries(&profile, &folder, Some(&operation), move |progress| {
+ let Some(controller) = progress_controller.upgrade() else {
+ return;
+ };
+ if controller.state.borrow().generation == generation {
+ controller.status_label.set_text(&format!(
+ "하위 폴더 검색 중... (폴더 {}개, 항목 {}개, 파일 {}개)",
+ progress.directories, progress.scanned, progress.viewable
+ ));
+ }
+ })
+ .await;
+ let Some(controller) = controller.upgrade() else {
+ return;
+ };
+ if controller.state.borrow().generation != generation {
+ return;
+ }
+ match result {
+ Ok((mut entries, progress)) => {
+ entries.retain(|entry| entry.kind.is_viewable());
+ sort_entries(&mut entries, sort_field, sort_direction, case_insensitive);
+ let Some(initial) = entries.first().cloned() else {
+ controller
+ .status_label
+ .set_text("하위 폴더에 열 수 있는 파일이 없습니다.");
+ return;
+ };
+ let skipped = if progress.skipped == 0 {
+ String::new()
+ } else {
+ format!(" · 접근할 수 없는 폴더 {}개 건너뜀", progress.skipped)
+ };
+ controller.status_label.set_text(&format!(
+ "하위 폴더에서 {}개 파일을 찾았습니다{skipped}.",
+ entries.len()
+ ));
+ controller.open_viewable(initial, Rc::new(entries), profile, None);
+ }
+ Err(error) => controller
+ .status_label
+ .set_text(&format!("하위 폴더를 열 수 없습니다: {error:#}")),
+ }
+ });
+ self.listing_task.replace(Some(task));
+ }
+
+ fn favorite_control(
+ self: &Rc,
+ entry: &BrowserEntry,
+ profile: &LocationProfile,
+ ) -> FavoriteControl {
+ let entry = entry.clone();
+ let profile = profile.clone();
+ let controller = Rc::downgrade(self);
+ FavoriteControl {
+ active: self.is_favorite(&entry.uri),
+ toggle: Rc::new(move || {
+ let Some(controller) = controller.upgrade() else {
+ return false;
+ };
+ controller.toggle_favorite(&entry, &profile)
+ }),
+ }
+ }
+
+ fn download_control(self: &Rc, entry: &BrowserEntry) -> FileDownloadControl {
+ let entry = entry.clone();
+ let controller = Rc::downgrade(self);
+ FileDownloadControl {
+ download: Rc::new(move |parent, status_label| {
+ let Some(controller) = controller.upgrade() else {
+ return;
+ };
+ controller.choose_download_destination(entry.clone(), parent, status_label);
+ }),
+ }
+ }
+
+ fn file_drop_control(self: &Rc) -> FileDropControl {
+ let controller = Rc::downgrade(self);
+ FileDropControl {
+ handle: Rc::new(move |files, parent| {
+ if let Some(controller) = controller.upgrade() {
+ controller.open_dropped_files(files, parent);
+ }
+ }),
+ }
+ }
+
+ fn open_dropped_files(self: &Rc, files: Vec, parent: gtk::Window) {
+ let [file] = files.as_slice() else {
+ show_drop_error(&parent, "한 번에 하나의 파일 또는 폴더만 열 수 있습니다.");
+ return;
+ };
+ if !file.is_native() {
+ show_drop_error(&parent, "로컬 파일 또는 폴더만 드래그해서 열 수 있습니다.");
+ return;
+ }
+ let file = file.clone();
+ self.cancel_listing();
+ let generation = {
+ let mut state = self.state.borrow_mut();
+ state.generation = state.generation.wrapping_add(1);
+ state.generation
+ };
+ self.status_label.set_text("열 항목을 확인하는 중...");
+ let controller = Rc::downgrade(self);
+ let task = glib::MainContext::default().spawn_local(async move {
+ let result: Result<_> = async {
+ let info = file
+ .query_info_future(
+ "standard::type,standard::display-name",
+ gio::FileQueryInfoFlags::NONE,
+ glib::Priority::DEFAULT,
+ )
+ .await
+ .context("열 항목을 확인할 수 없습니다")?;
+ let selected = match info.file_type() {
+ gio::FileType::Directory => None,
+ gio::FileType::Regular => {
+ if !classify_file(Path::new(info.display_name().as_str())).is_viewable() {
+ bail!("지원하지 않는 파일 형식입니다: {}", info.display_name());
+ }
+ Some(file.clone())
+ }
+ _ => bail!("일반 파일 또는 폴더만 열 수 있습니다"),
+ };
+ let directory = selected
+ .as_ref()
+ .and_then(gio::File::parent)
+ .unwrap_or_else(|| file.clone());
+ let profile = local_profile_for_directory(&directory)?;
+ let operation = mount_operation(&profile, &parent);
+ let entries =
+ enumerate_directory(&profile, directory.uri().as_str(), &operation, |_| {})
+ .await?;
+ Ok((directory, profile, entries, selected))
+ }
+ .await;
+
+ let Some(controller) = controller.upgrade() else {
+ return;
+ };
+ if controller.state.borrow().generation != generation || !parent.is_visible() {
+ return;
+ }
+ let (directory, profile, entries, selected) = match result {
+ Ok(result) => result,
+ Err(error) => {
+ let message = format!("항목을 열 수 없습니다: {error:#}");
+ controller.status_label.set_text(&message);
+ show_drop_error(&parent, &message);
+ return;
+ }
+ };
+ controller.show_dropped_directory(&directory, profile.clone(), entries.clone());
+ let Some(selected) = selected else {
+ return;
+ };
+ let Some(entry) = entries
+ .iter()
+ .find(|entry| gio::File::for_uri(&entry.uri).equal(&selected))
+ .cloned()
+ else {
+ show_drop_error(&parent, "파일을 부모 폴더에서 찾을 수 없습니다.");
+ return;
+ };
+ let state = controller.state.borrow();
+ let Some((siblings, _selected_index)) = sorted_navigable_selection(
+ &entries,
+ &entry.uri,
+ state.sort_field,
+ state.sort_direction,
+ controller.config.borrow().case_insensitive_sort,
+ ) else {
+ drop(state);
+ show_drop_error(&parent, "파일의 목록 위치를 확인할 수 없습니다.");
+ return;
+ };
+ drop(state);
+ controller.open_viewable(entry, Rc::new(siblings), profile, None);
+ });
+ self.listing_task.replace(Some(task));
+ }
+
+ fn show_dropped_directory(
+ &self,
+ directory: &gio::File,
+ profile: LocationProfile,
+ entries: Vec,
+ ) {
+ self.location_dropdown
+ .set_selected(gtk::INVALID_LIST_POSITION);
+ self.edit_location_button.set_sensitive(false);
+ self.delete_location_button.set_sensitive(false);
+ self.path_entry.set_editable(true);
+ let uri: String = directory.uri().into();
+ let mut state = self.state.borrow_mut();
+ state.favorite_profile = Some(profile);
+ state.mode = BrowserMode::Directory;
+ state.root_uri = uri.clone();
+ state.current_uri = uri.clone();
+ state.entries = entries;
+ state.typeahead_query.clear();
+ state.typeahead_last_input = None;
+ drop(state);
+ self.update_mode_controls(BrowserMode::Directory);
+ self.path_entry.set_text(&display_uri(&uri));
+ self.search_entry.set_text("");
+ self.render();
+ self.window.present();
+ }
+
+ fn view_mode_control(self: &Rc) -> ViewModeControl {
+ let selected = self.config.borrow().viewer_mode.dropdown_index();
+ let controller = Rc::downgrade(self);
+ ViewModeControl {
+ selected,
+ change: Rc::new(move |index| {
+ let Some(controller) = controller.upgrade() else {
+ return;
+ };
+ let viewer_mode = ViewerMode::from_dropdown_index(index);
+ if controller.config.borrow().viewer_mode == viewer_mode {
+ return;
+ }
+ let mut updated = controller.config.borrow().clone();
+ updated.viewer_mode = viewer_mode;
+ if let Err(error) = updated.save(&controller.config_path) {
+ controller
+ .status_label
+ .set_text(&format!("보기 모드를 저장할 수 없습니다: {error:#}"));
+ return;
+ }
+ *controller.config.borrow_mut() = updated;
+ }),
+ }
+ }
+
+ fn two_page_direction_control(self: &Rc) -> TwoPageDirectionControl {
+ let selected = u32::from(self.config.borrow().two_page_right_to_left);
+ let controller = Rc::downgrade(self);
+ TwoPageDirectionControl {
+ selected,
+ change: Rc::new(move |index| {
+ let Some(controller) = controller.upgrade() else {
+ return false;
+ };
+ let right_to_left = index == 1;
+ if controller.config.borrow().two_page_right_to_left == right_to_left {
+ return true;
+ }
+ let mut updated = controller.config.borrow().clone();
+ updated.two_page_right_to_left = right_to_left;
+ if let Err(error) = updated.save(&controller.config_path) {
+ controller
+ .status_label
+ .set_text(&format!("2페이지 방향을 저장할 수 없습니다: {error:#}"));
+ return false;
+ }
+ *controller.config.borrow_mut() = updated;
+ true
+ }),
+ }
+ }
+
+ fn toggle_favorite(&self, entry: &BrowserEntry, profile: &LocationProfile) -> bool {
+ let mut updated = self.config.borrow().clone();
+ let was_active = self.is_favorite(&entry.uri);
+ let active = toggle_favorite_entry(&mut updated, entry, profile);
+ if let Err(error) = updated.save(&self.config_path) {
+ self.status_label
+ .set_text(&format!("즐겨찾기를 저장할 수 없습니다: {error:#}"));
+ return was_active;
+ }
+ *self.config.borrow_mut() = updated;
+ if self.state.borrow().mode == BrowserMode::Favorites {
+ self.show_favorites();
+ }
+ self.status_label.set_text(if active {
+ "즐겨찾기에 추가했습니다."
+ } else {
+ "즐겨찾기에서 제거했습니다."
+ });
+ active
+ }
+
+ fn record_recent_file(&self, entry: &BrowserEntry, profile: &LocationProfile) {
+ let mut updated = self.config.borrow().clone();
+ record_recent_file(&mut updated, entry, profile);
+ if let Err(error) = updated.save(&self.config_path) {
+ self.status_label
+ .set_text(&format!("최근 파일 기록을 저장할 수 없습니다: {error:#}"));
+ return;
+ }
+ *self.config.borrow_mut() = updated;
+ if self.state.borrow().mode == BrowserMode::Recent {
+ let entries = self
+ .config
+ .borrow()
+ .recent_files
+ .iter()
+ .map(recent_file_browser_entry)
+ .collect();
+ self.state.borrow_mut().entries = entries;
+ self.render();
+ }
+ }
+
+ fn choose_download_destination(
+ self: &Rc,
+ entry: BrowserEntry,
+ parent: gtk::Window,
+ status_label: gtk::Label,
+ ) {
+ let dialog = gtk::FileDialog::builder()
+ .title("다운로드 위치 선택")
+ .initial_name(&entry.name)
+ .build();
+ let controller = Rc::downgrade(self);
+ glib::MainContext::default().spawn_local(async move {
+ let result = dialog.save_future(Some(&parent)).await;
+ let Some(controller) = controller.upgrade() else {
+ return;
+ };
+ match result {
+ Ok(destination) if destination.is_native() => {
+ controller.download_file(entry, destination, status_label);
+ }
+ Ok(_) => status_label.set_text("로컬 파일 시스템 위치를 선택해 주세요."),
+ Err(error) if error.matches(gio::IOErrorEnum::Cancelled) => {}
+ Err(error) => {
+ status_label.set_text(&format!("저장 위치를 선택할 수 없습니다: {error}"));
+ }
+ }
+ });
+ }
+
+ fn download_file(&self, entry: BrowserEntry, destination: gio::File, status_label: gtk::Label) {
+ let Some(final_path) = destination.path() else {
+ status_label.set_text("로컬 파일 시스템 위치를 선택해 주세요.");
+ return;
+ };
+ let part_path = download_part_path(&final_path);
+ let source = gio::File::for_uri(&entry.uri);
+ let part_file = gio::File::for_path(&part_path);
+ let progress_label = status_label.clone();
+ let result_label = status_label;
+ let expected_size = entry.size;
+ source.copy_async(
+ &part_file,
+ gio::FileCopyFlags::OVERWRITE,
+ glib::Priority::DEFAULT,
+ gio::Cancellable::NONE,
+ Some(Box::new(move |current, total| {
+ let percent = if total > 0 { current * 100 / total } else { 0 };
+ progress_label.set_text(&format!("{} 다운로드 중... {percent}%", entry.name));
+ })),
+ move |result| {
+ let completed = result.map_err(anyhow::Error::from).and_then(|()| {
+ let actual_size = fs::metadata(&part_path)?.len();
+ if expected_size.is_some_and(|expected| expected != actual_size) {
+ anyhow::bail!("다운로드 크기가 원본과 다릅니다.");
+ }
+ fs::rename(&part_path, &final_path)?;
+ Ok(())
+ });
+ if let Err(error) = completed {
+ let _ = fs::remove_file(&part_path);
+ result_label.set_text(&format!("다운로드 실패: {error:#}"));
+ } else {
+ result_label.set_text(&format!("다운로드 완료: {}", final_path.display()));
+ }
+ },
+ );
+ }
+
+ fn set_case_insensitive_sort(&self, check: >k::CheckButton) {
+ let active = check.is_active();
+ let previous = self.config.borrow().case_insensitive_sort;
+ if active == previous {
+ return;
+ }
+ let mut updated = self.config.borrow().clone();
+ updated.case_insensitive_sort = active;
+ match updated.save(&self.config_path) {
+ Ok(()) => {
+ *self.config.borrow_mut() = updated;
+ self.render();
+ }
+ Err(error) => {
+ self.status_label
+ .set_text(&format!("정렬 설정을 저장할 수 없습니다: {error:#}"));
+ check.set_active(previous);
+ }
+ }
+ }
+
fn set_fast_image_loading(&self, switch: >k::Switch) {
let active = switch.is_active();
let previous = self.config.borrow().fast_image_loading;
@@ -542,6 +1796,153 @@ impl BrowserController {
(index < self.config.borrow().locations.len()).then_some(index)
}
+ fn show_about_dialog(&self) {
+ let dialog = gtk::Window::builder()
+ .title("Comicviewer 정보")
+ .transient_for(&self.window)
+ .modal(true)
+ .resizable(false)
+ .default_width(520)
+ .build();
+ let content = gtk::Box::new(gtk::Orientation::Vertical, 14);
+ content.set_margin_top(24);
+ content.set_margin_bottom(16);
+ content.set_margin_start(24);
+ content.set_margin_end(24);
+ let name = gtk::Label::new(Some(&format!(
+ "Comicviewer ({})",
+ env!("CARGO_PKG_VERSION")
+ )));
+ name.add_css_class("title-2");
+ let contact = gtk::Label::new(Some("개발자 연락처 : burningtuna@gmail.com"));
+ let libraries = gtk::Label::new(Some(
+ "사용한 라이브러리\n\
+ GTK4 / GIO · GStreamer · image · zip · rusqlite / SQLite\n\
+ serde · toml · anyhow · chrono · filetime · percent-encoding\n\
+ sha2 · tempfile · flate2 · tar",
+ ));
+ libraries.set_xalign(0.0);
+ libraries.set_wrap(true);
+ let close_button = gtk::Button::with_label("닫기");
+ let update_button = gtk::Button::with_label("업데이트");
+ let update_status = gtk::Label::new(None);
+ update_status.set_wrap(true);
+ update_status.set_xalign(0.0);
+ let actions = gtk::Box::new(gtk::Orientation::Horizontal, 8);
+ actions.set_halign(gtk::Align::End);
+ actions.append(&update_button);
+ actions.append(&close_button);
+ if self.update_in_progress.get() {
+ update_button.set_sensitive(false);
+ update_status.set_text("다른 업데이트 작업이 진행 중입니다.");
+ }
+ let dialog_to_close = dialog.clone();
+ close_button.connect_clicked(move |_| dialog_to_close.close());
+ let status = update_status.clone();
+ let update_in_progress = Rc::clone(&self.update_in_progress);
+ update_button.connect_clicked(move |button| {
+ if update_in_progress.replace(true) {
+ return;
+ }
+ button.set_sensitive(false);
+ status.set_text("업데이트를 다운로드하고 검증하는 중...");
+ let (sender, receiver) = mpsc::channel();
+ thread::spawn(move || {
+ let result = install_latest_update().map_err(|error| format!("{error:#}"));
+ let _ = sender.send(result);
+ });
+ let button = button.clone();
+ let status = status.clone();
+ let update_in_progress = Rc::clone(&update_in_progress);
+ glib::timeout_add_local(Duration::from_millis(100), move || {
+ match receiver.try_recv() {
+ Ok(Ok(())) => {
+ update_in_progress.set(false);
+ status.set_text(
+ "업데이트를 완료했습니다. 앱을 종료한 뒤 ~/.local/bin/comicviewer로 다시 실행해 주세요.",
+ );
+ button.set_label("업데이트 완료");
+ glib::ControlFlow::Break
+ }
+ Ok(Err(error)) => {
+ update_in_progress.set(false);
+ status.set_text(&format!("업데이트 실패: {error}"));
+ button.set_sensitive(true);
+ glib::ControlFlow::Break
+ }
+ Err(mpsc::TryRecvError::Empty) => glib::ControlFlow::Continue,
+ Err(mpsc::TryRecvError::Disconnected) => {
+ update_in_progress.set(false);
+ status.set_text("업데이트 작업이 예기치 않게 종료되었습니다.");
+ button.set_sensitive(true);
+ glib::ControlFlow::Break
+ }
+ }
+ });
+ });
+ content.append(&name);
+ content.append(&contact);
+ content.append(&libraries);
+ content.append(&update_status);
+ content.append(&actions);
+ dialog.set_child(Some(&content));
+ dialog.present();
+ }
+
+ fn show_clear_cache_dialog(self: &Rc) {
+ let dialog = gtk::Window::builder()
+ .title("캐시 비우기")
+ .transient_for(&self.window)
+ .modal(true)
+ .resizable(false)
+ .default_width(440)
+ .build();
+ let content = gtk::Box::new(gtk::Orientation::Vertical, 16);
+ content.set_margin_top(18);
+ content.set_margin_bottom(12);
+ content.set_margin_start(18);
+ content.set_margin_end(18);
+ let message = gtk::Label::new(Some(
+ "다운로드한 ZIP 캐시를 삭제하시겠습니까?\n현재 열려 있는 ZIP과 읽기 기록은 유지됩니다.",
+ ));
+ message.set_wrap(true);
+ message.set_xalign(0.0);
+ let actions = gtk::Box::new(gtk::Orientation::Horizontal, 6);
+ actions.set_halign(gtk::Align::End);
+ let cancel_button = gtk::Button::with_label("취소");
+ let clear_button = gtk::Button::with_label("캐시 삭제");
+ clear_button.add_css_class("destructive-action");
+ actions.append(&cancel_button);
+ actions.append(&clear_button);
+ content.append(&message);
+ content.append(&actions);
+ dialog.set_child(Some(&content));
+
+ let dialog_to_close = dialog.clone();
+ cancel_button.connect_clicked(move |_| dialog_to_close.close());
+ let controller = Rc::clone(self);
+ let dialog_to_close = dialog.clone();
+ clear_button.connect_clicked(move |_| match controller.zip_cache.clear_persistent() {
+ Ok(report) => {
+ let removed_mib = report.removed_bytes as f64 / (1024.0 * 1024.0);
+ let retained = if report.retained_open_files == 0 {
+ String::new()
+ } else {
+ format!(", 열려 있어 유지한 파일 {}개", report.retained_open_files)
+ };
+ controller.status_label.set_text(&format!(
+ "ZIP 캐시 {}개({removed_mib:.1} MiB)를 삭제했습니다{retained}.",
+ report.removed_files
+ ));
+ dialog_to_close.close();
+ }
+ Err(error) => controller
+ .status_label
+ .set_text(&format!("캐시를 삭제할 수 없습니다: {error:#}")),
+ });
+ dialog.present();
+ }
+
fn show_location_dialog(self: &Rc, edit_index: Option) {
let existing =
edit_index.and_then(|index| self.config.borrow().locations.get(index).cloned());
@@ -712,6 +2113,202 @@ impl BrowserController {
});
dialog.present();
}
+
+ fn show_clear_recent_dialog(self: &Rc) {
+ let dialog = gtk::Window::builder()
+ .title("최근 기록 비우기")
+ .transient_for(&self.window)
+ .modal(true)
+ .resizable(false)
+ .default_width(420)
+ .build();
+ let content = gtk::Box::new(gtk::Orientation::Vertical, 16);
+ content.set_margin_top(18);
+ content.set_margin_bottom(12);
+ content.set_margin_start(18);
+ content.set_margin_end(18);
+ let message = gtk::Label::new(Some(
+ "최근 열어본 파일 기록을 모두 삭제하시겠습니까?\n즐겨찾기와 ZIP 읽기 진행도는 유지됩니다.",
+ ));
+ message.set_wrap(true);
+ message.set_xalign(0.0);
+ let actions = gtk::Box::new(gtk::Orientation::Horizontal, 6);
+ actions.set_halign(gtk::Align::End);
+ let cancel_button = gtk::Button::with_label("취소");
+ let clear_button = gtk::Button::with_label("모두 삭제");
+ clear_button.add_css_class("destructive-action");
+ actions.append(&cancel_button);
+ actions.append(&clear_button);
+ content.append(&message);
+ content.append(&actions);
+ dialog.set_child(Some(&content));
+
+ let dialog_to_close = dialog.clone();
+ cancel_button.connect_clicked(move |_| dialog_to_close.close());
+ let controller = Rc::clone(self);
+ let dialog_to_close = dialog.clone();
+ clear_button.connect_clicked(move |_| {
+ let mut updated = controller.config.borrow().clone();
+ updated.recent_files.clear();
+ if let Err(error) = updated.save(&controller.config_path) {
+ controller
+ .status_label
+ .set_text(&format!("최근 기록을 삭제할 수 없습니다: {error:#}"));
+ return;
+ }
+ *controller.config.borrow_mut() = updated;
+ controller.show_recent();
+ controller
+ .status_label
+ .set_text("최근 기록을 삭제했습니다.");
+ dialog_to_close.close();
+ });
+ dialog.present();
+ }
+}
+
+fn install_latest_update() -> Result<()> {
+ let directory = tempfile::tempdir().context("업데이트 임시 폴더를 만들 수 없습니다")?;
+ let archive = directory.path().join("Comicviewer-latest-x86_64.tar.gz");
+ let checksum = directory
+ .path()
+ .join("Comicviewer-latest-x86_64.tar.gz.sha256");
+ download_update_file(UPDATE_BUNDLE_URL, &archive)?;
+ download_update_file(UPDATE_CHECKSUM_URL, &checksum)?;
+
+ let checksum_text =
+ fs::read_to_string(&checksum).context("업데이트 체크섬을 읽을 수 없습니다")?;
+ let expected = parse_update_checksum(&checksum_text)?;
+ let actual = sha256_file(&archive)?;
+ if actual != expected {
+ bail!("다운로드한 업데이트 체크섬이 일치하지 않습니다");
+ }
+
+ let extraction = directory.path().join("extracted");
+ fs::create_dir(&extraction).context("업데이트 압축 해제 폴더를 만들 수 없습니다")?;
+ extract_update_archive(&archive, &extraction)?;
+ let installer = extraction
+ .join("Comicviewer-latest-x86_64")
+ .join("install-or-update.sh");
+ if !installer.is_file() {
+ bail!("업데이트 번들에 설치 스크립트가 없습니다");
+ }
+ run_update_command(
+ Command::new("sh")
+ .arg(&installer)
+ .env("COMICVIEWER_SKIP_DEPENDENCIES", "1"),
+ "업데이트 설치에 실패했습니다",
+ )
+}
+
+fn download_update_file(url: &str, destination: &Path) -> Result<()> {
+ let url = format!("{url}?from={}", env!("CARGO_PKG_VERSION"));
+ run_update_command(
+ Command::new("curl")
+ .arg("--fail")
+ .arg("--silent")
+ .arg("--show-error")
+ .arg("--location")
+ .arg("--proto")
+ .arg("=https")
+ .arg("--proto-redir")
+ .arg("=https")
+ .arg("--connect-timeout")
+ .arg("15")
+ .arg("--max-time")
+ .arg("300")
+ .arg("--max-filesize")
+ .arg((512_u64 * 1024 * 1024).to_string())
+ .arg("--retry")
+ .arg("3")
+ .arg("--output")
+ .arg(destination)
+ .arg(url),
+ "업데이트를 다운로드할 수 없습니다. curl 설치와 네트워크 연결을 확인해 주세요",
+ )
+}
+
+fn run_update_command(command: &mut Command, context: &str) -> Result<()> {
+ let output = command.output().with_context(|| context.to_owned())?;
+ if output.status.success() {
+ return Ok(());
+ }
+ let stderr = String::from_utf8_lossy(&output.stderr)
+ .trim()
+ .chars()
+ .take(600)
+ .collect::();
+ if stderr.is_empty() {
+ bail!("{context}");
+ }
+ bail!("{context}: {stderr}")
+}
+
+fn extract_update_archive(archive_path: &Path, destination: &Path) -> Result<()> {
+ const MAX_ENTRIES: usize = 32;
+ const MAX_EXTRACTED_BYTES: u64 = 512 * 1024 * 1024;
+
+ let file = fs::File::open(archive_path).context("업데이트 압축 파일을 열 수 없습니다")?;
+ let decoder = GzDecoder::new(file);
+ let mut archive = Archive::new(decoder);
+ let mut count = 0_usize;
+ let mut extracted_bytes = 0_u64;
+ for entry in archive
+ .entries()
+ .context("업데이트 압축 목록을 읽을 수 없습니다")?
+ {
+ let mut entry = entry.context("업데이트 압축 항목을 읽을 수 없습니다")?;
+ count += 1;
+ if count > MAX_ENTRIES {
+ bail!("업데이트 압축 항목 수가 안전 제한을 초과합니다");
+ }
+ let entry_type = entry.header().entry_type();
+ if !entry_type.is_file() && !entry_type.is_dir() {
+ bail!("업데이트 압축에 허용되지 않은 파일 종류가 있습니다");
+ }
+ let path = entry
+ .path()
+ .context("업데이트 압축 경로가 올바르지 않습니다")?;
+ if !path.starts_with("Comicviewer-latest-x86_64") {
+ bail!("업데이트 압축 경로가 올바르지 않습니다");
+ }
+ extracted_bytes = extracted_bytes.saturating_add(entry.header().size().unwrap_or(u64::MAX));
+ if extracted_bytes > MAX_EXTRACTED_BYTES {
+ bail!("업데이트 압축 크기가 안전 제한을 초과합니다");
+ }
+ if !entry
+ .unpack_in(destination)
+ .context("업데이트 압축을 풀 수 없습니다")?
+ {
+ bail!("업데이트 압축 경로가 임시 폴더를 벗어납니다");
+ }
+ }
+ Ok(())
+}
+
+fn parse_update_checksum(contents: &str) -> Result {
+ let checksum = contents
+ .split_whitespace()
+ .next()
+ .filter(|checksum| {
+ checksum.len() == 64 && checksum.chars().all(|value| value.is_ascii_hexdigit())
+ })
+ .context("업데이트 체크섬 파일이 올바르지 않습니다")?;
+ Ok(checksum.to_ascii_lowercase())
+}
+
+fn sha256_file(path: &Path) -> Result {
+ let mut file = fs::File::open(path).context("다운로드한 업데이트를 읽을 수 없습니다")?;
+ let mut digest = Sha256::new();
+ let mut buffer = [0_u8; 64 * 1024];
+ loop {
+ let count = file.read(&mut buffer)?;
+ if count == 0 {
+ break;
+ }
+ digest.update(&buffer[..count]);
+ }
+ Ok(format!("{:x}", digest.finalize()))
}
fn location_kind_index(kind: LocationKind) -> u32 {
@@ -734,6 +2331,37 @@ fn home_profile() -> LocationProfile {
}
}
+fn local_profile_for_directory(directory: &gio::File) -> Result {
+ let path = directory
+ .path()
+ .context("로컬 폴더 경로를 확인할 수 없습니다")?;
+ let address = path
+ .to_str()
+ .context("UTF-8로 표현할 수 없는 로컬 경로는 열 수 없습니다")?;
+ let name = path
+ .file_name()
+ .and_then(|name| name.to_str())
+ .filter(|name| !name.is_empty())
+ .unwrap_or(address)
+ .to_owned();
+ Ok(LocationProfile {
+ name,
+ kind: LocationKind::Local,
+ address: address.to_owned(),
+ username: String::new(),
+ password: String::new(),
+ domain: String::new(),
+ })
+}
+
+fn show_drop_error(parent: >k::Window, message: &str) {
+ gtk::AlertDialog::builder()
+ .modal(true)
+ .message(message)
+ .build()
+ .show(Some(parent));
+}
+
fn display_uri(uri: &str) -> String {
let file = gio::File::for_uri(uri);
file.path().map_or_else(
@@ -742,34 +2370,53 @@ fn display_uri(uri: &str) -> String {
)
}
-fn entry_row(entry: &BrowserEntry) -> gtk::ListBoxRow {
- let row = gtk::ListBoxRow::new();
+fn entry_content() -> gtk::Box {
let content = gtk::Box::new(gtk::Orientation::Horizontal, 12);
content.set_margin_top(8);
content.set_margin_bottom(8);
content.set_margin_start(10);
content.set_margin_end(10);
- let icon = match entry.kind {
- EntryKind::Directory => "folder-symbolic",
- EntryKind::ZipArchive => "package-x-generic-symbolic",
- };
- content.append(>k::Image::from_icon_name(icon));
+ content.append(>k::Image::new());
content.append(
>k::Label::builder()
- .label(&entry.name)
.hexpand(true)
.xalign(0.0)
.ellipsize(gtk::pango::EllipsizeMode::Middle)
.build(),
);
- for time in [entry.modified, entry.created] {
- let label = gtk::Label::new(Some(&format_time(time)));
+ for _ in 0..2 {
+ let label = gtk::Label::new(None);
label.set_width_chars(17);
label.set_xalign(1.0);
content.append(&label);
}
- row.set_child(Some(&content));
- row
+ content
+}
+
+fn bind_entry_content(content: >k::Box, entry: &BrowserEntry) {
+ let icon_name = match entry.kind {
+ EntryKind::Directory => "folder-symbolic",
+ EntryKind::ZipArchive => "package-x-generic-symbolic",
+ EntryKind::Image => "image-x-generic-symbolic",
+ EntryKind::Video => "video-x-generic-symbolic",
+ EntryKind::OtherFile => "text-x-generic-symbolic",
+ };
+ let Some(icon) = content.first_child().and_downcast::() else {
+ return;
+ };
+ icon.set_icon_name(Some(icon_name));
+ let Some(name) = icon.next_sibling().and_downcast::