diff --git a/.gitignore b/.gitignore index e899205..6ce25f6 100644 --- a/.gitignore +++ b/.gitignore @@ -3,10 +3,3 @@ /.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 39e7884..64ce761 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 ZIP archives, -standalone images, and videos. +It browses local, SMB, FTP, and SFTP locations and opens image files stored in +ZIP archives. ## Technology - Rust - GTK4 with GIO/GVfs for desktop and remote filesystem integration -- SQLite for cached directory metadata and reading history +- SQLite for cached directory metadata, search indexes, and reading history - AppImage as the primary distribution format - Korean-first UI with all user-facing strings kept translatable @@ -20,46 +20,20 @@ standalone images, and videos. - 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. -- 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. +- Support JPEG, PNG, WebP, static GIF, BMP, and AVIF images in ZIP archives. - 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. -- Filter the currently displayed browser directory by filename and restore all - entries when the search text is cleared. +- Search folder and ZIP names recursively below the current location using the + cached index. - 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. 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. + that advance by one page to adjust page pairing. - 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 @@ -76,23 +50,11 @@ 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, 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. +- Validate archive entry sizes and image dimensions before allocation. - 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. @@ -112,13 +74,8 @@ cargo clippy --all-targets --all-features -- -D warnings cargo test --all-features ``` -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. +Add focused tests for natural sorting, cache eviction, metadata refresh, +archive filtering, reading progress, and remote file change detection. ## Git Practices diff --git a/Cargo.lock b/Cargo.lock index 44ba40a..6731395 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -182,19 +182,17 @@ checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b" [[package]] name = "comicviewer" -version = "0.2.20" +version = "0.1.0" dependencies = [ "anyhow", "chrono", "filetime", - "flate2", "gtk4", "image", "percent-encoding", "rusqlite", "serde", "sha2", - "tar", "tempfile", "toml 0.9.12+spec-1.1.0", "zip", @@ -1213,17 +1211,6 @@ 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" @@ -1488,16 +1475,6 @@ 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 3b72bf0..cc97e95 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "comicviewer" -version = "0.2.20" +version = "0.1.0" edition = "2024" description = "A comic archive viewer for local and remote locations" license = "GPL-3.0-or-later" @@ -8,16 +8,14 @@ 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_12"] } +gtk = { package = "gtk4", version = "0.10", features = ["v4_10"] } 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 2fcfc44..cd0cdc1 100644 --- a/README.md +++ b/README.md @@ -1,26 +1,20 @@ # Comicviewer -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) +Comicviewer is a GTK4 desktop application for browsing and reading comic image +archives stored locally or on SMB, FTP, and SFTP servers. 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, standalone image and video -playback, reading progress, and XDG-compliant configuration. +two-page viewing, continuous vertical scrolling, reading progress, and +XDG-compliant configuration. ## Development dependencies On CachyOS or Arch Linux: ```sh -sudo pacman -S rust gtk4 dav1d sqlite gvfs gvfs-smb gstreamer \ - gst-plugins-base gst-plugins-good gst-plugins-bad gst-libav +sudo pacman -S rust gtk4 sqlite gvfs gvfs-smb ``` Run the application with: @@ -29,17 +23,16 @@ Run the application with: cargo run ``` -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. +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. 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 `appimagetool`. The script can extract appimagetool -from a linuxdeploy AppImage when it is not provided directly: +The AppImage build uses `linuxdeploy` and `linuxdeploy-plugin-gtk`: ```sh PATH="/path/to/appimage-tools:$PATH" \ diff --git a/data/io.github.comicviewer.Comicviewer.desktop b/data/io.github.comicviewer.Comicviewer.desktop index ee70b54..7578ae7 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 %f +Exec=comicviewer Icon=io.github.comicviewer.Comicviewer Terminal=false Categories=Graphics;Viewer; -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; +MimeType=application/zip;application/vnd.comicbook+zip; StartupNotify=true diff --git a/data/io.github.comicviewer.Comicviewer.metainfo.xml b/data/io.github.comicviewer.Comicviewer.metainfo.xml index 1949cfa..1aca08d 100644 --- a/data/io.github.comicviewer.Comicviewer.metainfo.xml +++ b/data/io.github.comicviewer.Comicviewer.metainfo.xml @@ -26,31 +26,6 @@ - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/dist/Comicviewer-0.1.0-x86_64.AppImage.sha256 b/dist/Comicviewer-0.1.0-x86_64.AppImage.sha256 deleted file mode 100644 index 1b41400..0000000 --- a/dist/Comicviewer-0.1.0-x86_64.AppImage.sha256 +++ /dev/null @@ -1 +0,0 @@ -ae696a3913804a39f304d6b111fc987973e81a3a37aa5d50089e5dfe490ac2f0 Comicviewer-0.1.0-x86_64.AppImage diff --git a/docs/INSTALL.ko.md b/docs/INSTALL.ko.md deleted file mode 100644 index 4c2b483..0000000 --- a/docs/INSTALL.ko.md +++ /dev/null @@ -1,111 +0,0 @@ -# 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 deleted file mode 100644 index b124f8f..0000000 --- a/docs/RELEASING.ko.md +++ /dev/null @@ -1,121 +0,0 @@ -# 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 087ee51..b0fafed 100755 --- a/packaging/build-appimage.sh +++ b/packaging/build-appimage.sh @@ -3,10 +3,7 @@ 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" @@ -17,47 +14,34 @@ trap cleanup EXIT cargo build --manifest-path "${root_dir}/Cargo.toml" --release mkdir -p "${output_dir}" -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" +mkdir -p "${app_dir}/usr/share/metainfo" 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-${version}-x86_64.AppImage" +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 -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" +# 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}" fi -env ARCH=x86_64 APPIMAGE_EXTRACT_AND_RUN=1 \ - "${appimagetool}" "${app_dir}" "${output_path}" +"${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 echo "Created ${output_path}" diff --git a/packaging/build-release-bundle.sh b/packaging/build-release-bundle.sh deleted file mode 100755 index 10e6025..0000000 --- a/packaging/build-release-bundle.sh +++ /dev/null @@ -1,56 +0,0 @@ -#!/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 deleted file mode 100755 index fbc1893..0000000 --- a/packaging/install-or-update.sh +++ /dev/null @@ -1,127 +0,0 @@ -#!/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 eb7f661..04e6090 100644 --- a/src/archive.rs +++ b/src/archive.rs @@ -1,23 +1,16 @@ use std::fs::File; use std::io::{Cursor, Read}; use std::path::Path; -use std::time::Duration; use anyhow::{Context, Result, bail}; -use image::codecs::gif::GifDecoder; -use image::codecs::webp::WebPDecoder; -use image::metadata::LoopCount; -use image::{AnimationDecoder, ImageFormat, ImageReader}; +use image::ImageReader; use zip::ZipArchive; -use crate::browser::natural_cmp_with_case; +use crate::browser::natural_cmp; 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 { @@ -28,16 +21,10 @@ pub struct ArchivePage { pub struct DecodedPage { pub width: u32, pub height: u32, - pub frames: Vec, - pub loop_count: Option, -} - -pub struct DecodedFrame { pub rgba: Vec, - pub delay: Duration, } -pub fn list_pages(path: &Path, case_insensitive: bool) -> Result> { +pub fn list_pages(path: &Path) -> Result> { let file = File::open(path) .with_context(|| format!("ZIP 파일을 열 수 없습니다: {}", path.display()))?; let mut archive = ZipArchive::new(file) @@ -54,7 +41,7 @@ pub fn list_pages(path: &Path, case_insensitive: bool) -> Result Result { bail!("실제 압축 해제 크기가 제한을 초과합니다: {}", page.name); } - 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)) + let reader = ImageReader::new(Cursor::new(&encoded)) .with_guessed_format() - .with_context(|| format!("이미지 형식을 확인할 수 없습니다: {name}"))?; - let format = reader.format(); + .with_context(|| format!("이미지 형식을 확인할 수 없습니다: {}", page.name))?; let (width, height) = reader .into_dimensions() - .with_context(|| format!("이미지 크기를 읽을 수 없습니다: {name}"))?; - validate_dimensions(width, height, name)?; + .with_context(|| format!("이미지 크기를 읽을 수 없습니다: {}", page.name))?; + validate_dimensions(width, height, &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 image = image::load_from_memory(&encoded) + .with_context(|| format!("이미지를 디코딩할 수 없습니다: {}", page.name))?; let rgba = image.into_rgba8(); Ok(DecodedPage { width, height, - frames: vec![DecodedFrame { - rgba: rgba.into_raw(), - delay: Duration::ZERO, - }], - loop_count: Some(1), + rgba: rgba.into_raw(), }) } -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 @@ -272,7 +161,7 @@ mod tests { archive.write_all(b"ignored").unwrap(); archive.finish().unwrap(); - let pages = list_pages(&path, true).unwrap(); + let pages = list_pages(&path).unwrap(); assert_eq!( pages .iter() @@ -282,51 +171,8 @@ mod tests { ); let decoded = decode_page(&path, &pages[0]).unwrap(); assert_eq!((decoded.width, decoded.height), (2, 3)); - assert_eq!(decoded.frames[0].rgba.len(), 2 * 3 * 4); + assert_eq!(decoded.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 65b5d8a..1613747 100644 --- a/src/browser.rs +++ b/src/browser.rs @@ -6,22 +6,12 @@ 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, @@ -29,12 +19,6 @@ 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, @@ -48,19 +32,11 @@ pub enum SortDirection { Descending, } -pub fn sort_entries( - entries: &mut [BrowserEntry], - field: SortField, - direction: SortDirection, - case_insensitive: bool, -) { +pub fn sort_entries(entries: &mut [BrowserEntry], field: SortField, direction: SortDirection) { entries.sort_by(|left, right| { - let kind_order = match ( - left.kind == EntryKind::Directory, - right.kind == EntryKind::Directory, - ) { - (true, false) => Ordering::Less, - (false, true) => Ordering::Greater, + let kind_order = match (left.kind, right.kind) { + (EntryKind::Directory, EntryKind::ZipArchive) => Ordering::Less, + (EntryKind::ZipArchive, EntryKind::Directory) => Ordering::Greater, _ => Ordering::Equal, }; if kind_order != Ordering::Equal { @@ -68,32 +44,11 @@ pub fn sort_entries( } match field { - SortField::Name => apply_direction( - natural_cmp_with_case(left.display_name(), right.display_name(), case_insensitive), - direction, - ), + SortField::Name => apply_direction(natural_cmp(&left.name, &right.name), direction), SortField::Modified => compare_optional_time(left.modified, right.modified, direction) - .then_with(|| { - apply_direction( - natural_cmp_with_case( - left.display_name(), - right.display_name(), - case_insensitive, - ), - direction, - ) - }), + .then_with(|| apply_direction(natural_cmp(&left.name, &right.name), direction)), SortField::Created => compare_optional_time(left.created, right.created, direction) - .then_with(|| { - apply_direction( - natural_cmp_with_case( - left.display_name(), - right.display_name(), - case_insensitive, - ), - direction, - ) - }), + .then_with(|| apply_direction(natural_cmp(&left.name, &right.name), direction)), } }); } @@ -118,28 +73,19 @@ fn apply_direction(order: Ordering, direction: SortDirection) -> Ordering { } } -pub fn classify_file(path: &Path) -> EntryKind { - let extension = path - .extension() +pub fn is_zip_path(path: &Path) -> bool { + path.extension() .and_then(|extension| extension.to_str()) - .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, - } + .is_some_and(|extension| extension.eq_ignore_ascii_case("zip")) } -pub fn natural_cmp_with_case(left: &str, right: &str, case_insensitive: bool) -> Ordering { +pub fn natural_cmp(left: &str, right: &str) -> 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 left.cmp(right), + (None, None) => return Ordering::Equal, (None, Some(_)) => return Ordering::Less, (Some(_), None) => return Ordering::Greater, (Some(left_char), Some(right_char)) @@ -172,11 +118,10 @@ pub fn natural_cmp_with_case(left: &str, right: &str, case_insensitive: bool) -> (Some(_), Some(_)) => { let left_char = left_chars.next().unwrap(); let right_char = right_chars.next().unwrap(); - let order = if case_insensitive { - left_char.to_lowercase().cmp(right_char.to_lowercase()) - } else { - left_char.cmp(&right_char) - }; + let order = left_char + .to_lowercase() + .cmp(right_char.to_lowercase()) + .then_with(|| left_char.cmp(&right_char)); if order != Ordering::Equal { return order; } @@ -203,67 +148,22 @@ 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_with_case(left, right, true)); + names.sort_by(|left, right| natural_cmp(left, right)); assert_eq!(names, ["page1.jpg", "page2.jpg", "page10.jpg"]); } #[test] fn natural_order_handles_numbers_larger_than_integers() { assert_eq!( - natural_cmp_with_case("9.zip", "123456789012345678901234567890.zip", true), + natural_cmp("9.zip", "123456789012345678901234567890.zip"), 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_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); + assert!(is_zip_path(Path::new("comic.ZIP"))); + assert!(!is_zip_path(Path::new("comic.cbz"))); } #[test] diff --git a/src/config.rs b/src/config.rs index 905b382..0471dd2 100644 --- a/src/config.rs +++ b/src/config.rs @@ -10,12 +10,7 @@ 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 { @@ -23,12 +18,7 @@ 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(), } } } @@ -46,21 +36,6 @@ 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 { @@ -70,39 +45,6 @@ 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() { @@ -180,7 +122,6 @@ 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] @@ -188,9 +129,6 @@ 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, @@ -199,77 +137,16 @@ 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 dccd524..f48b1a6 100644 --- a/src/main.rs +++ b/src/main.rs @@ -8,86 +8,36 @@ 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) - .flags(application_flags()) - .build(); - let state = Rc::new(ApplicationState::default()); + let application = gtk::Application::builder().application_id(APP_ID).build(); - 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.connect_activate(|application| { + if let Err(error) = activate(application) { + eprintln!("Comicviewer를 시작하지 못했습니다: {error:#}"); + application.quit(); } }); application.run(); } -#[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)); - } +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(()) } diff --git a/src/source.rs b/src/source.rs index bf6b8e2..d9aab4a 100644 --- a/src/source.rs +++ b/src/source.rs @@ -1,4 +1,3 @@ -use std::collections::{HashSet, VecDeque}; use std::path::Path; use std::time::{Duration, UNIX_EPOCH}; @@ -8,47 +7,10 @@ use gtk::gio::prelude::*; use gtk::glib; use percent_encoding::percent_decode_str; -use crate::browser::{BrowserEntry, EntryKind, classify_file}; +use crate::browser::{BrowserEntry, EntryKind, is_zip_path}; 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)?; @@ -138,7 +100,7 @@ where } }; let mut entries = Vec::new(); - let mut enumeration = EnumerationProgress::default(); + let mut scanned = 0; loop { let batch = enumerator @@ -147,25 +109,24 @@ where if batch.is_empty() { break; } - enumeration.begin_batch(); + scanned += batch.len(); + progress(scanned); 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 => classify_file(Path::new(info.display_name().as_str())), + gio::FileType::Regular if is_zip_path(Path::new(info.display_name().as_str())) => { + EntryKind::ZipArchive + } _ => 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") @@ -181,151 +142,10 @@ 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, @@ -359,26 +179,6 @@ 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, @@ -421,16 +221,8 @@ 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] @@ -480,63 +272,4 @@ 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 eb0ee7c..d7ca3b7 100644 --- a/src/viewer.rs +++ b/src/viewer.rs @@ -1,16 +1,15 @@ -use std::cell::{Cell, RefCell}; +use std::cell::RefCell; use std::collections::{HashMap, HashSet, VecDeque}; -use std::rc::{Rc, Weak}; +use std::rc::Rc; use std::sync::mpsc::{self, TryRecvError}; use std::thread; -use std::time::{Duration, Instant}; +use std::time::Duration; use gtk::gdk; use gtk::glib; use gtk::prelude::*; -use crate::archive::{ArchivePage, DecodedPage, decode_image_file, decode_page, list_pages}; -use crate::browser::EntryKind; +use crate::archive::{ArchivePage, DecodedPage, decode_page, list_pages}; use crate::database::Database; use crate::zip_cache::ArchiveSource; @@ -18,314 +17,30 @@ 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 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 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 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")); - header.pack_end(&download_button); - header.pack_end(&favorite_button); - header.pack_end(&file_list_button); - let titlebar_host = set_viewer_header(&window, &header); + header.set_title_widget(Some(>k::Label::new(Some(&title)))); + window.set_titlebar(Some(&header)); let root = gtk::Box::new(gtk::Orientation::Vertical, 0); let toolbar = gtk::Box::new(gtk::Orientation::Horizontal, 6); @@ -346,8 +61,7 @@ impl ViewerWindow { let page_label = gtk::Label::new(Some("- / -")); page_label.set_hexpand(true); let direction_dropdown = gtk::DropDown::from_strings(&["좌→우", "우→좌"]); - let direction_selected = direction_control.selected.min(1); - direction_dropdown.set_selected(direction_selected); + direction_dropdown.set_selected(1); let mode_dropdown = gtk::DropDown::from_strings(&[ "100%", "폭 맞춤", @@ -355,7 +69,7 @@ impl ViewerWindow { "2페이지", "이어서 보기", ]); - mode_dropdown.set_selected(view_mode_control.selected); + mode_dropdown.set_selected(1); toolbar.append(&previous_button); toolbar.append(&shift_back_button); toolbar.append(&shift_forward_button); @@ -365,12 +79,10 @@ 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_box) + .child(&single_picture) .build(); let left_picture = page_picture(); let right_picture = page_picture(); @@ -378,11 +90,6 @@ 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); @@ -395,7 +102,7 @@ impl ViewerWindow { stack.set_hexpand(true); stack.set_vexpand(true); stack.add_named(&single_scrolled, Some("single")); - stack.add_named(&spread_scrolled, Some("spread")); + stack.add_named(&spread_box, Some("spread")); stack.add_named(&continuous_scrolled, Some("continuous")); let spinner = gtk::Spinner::new(); @@ -412,46 +119,23 @@ 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); - 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)); + window.set_child(Some(&root)); 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, @@ -460,41 +144,6 @@ 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, @@ -509,23 +158,6 @@ 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(); @@ -541,55 +173,16 @@ enum ViewMode { Continuous, } -#[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, + texture: gdk::MemoryTexture, 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 { @@ -607,24 +200,16 @@ 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, @@ -633,281 +218,48 @@ 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::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); + 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); self.direction_dropdown - .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); + .connect_selected_notify(move |_| controller.render()); let adjustment = self.continuous_scrolled.vadjustment(); - 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); + 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); self.continuous_scrolled .connect_notify_local(Some("width"), move |_, _| { - 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(); - } + controller.resize_continuous_rows(); }); let scroll_controller = gtk::EventControllerScroll::new( gtk::EventControllerScrollFlags::VERTICAL | gtk::EventControllerScrollFlags::DISCRETE, ); scroll_controller.set_propagation_phase(gtk::PropagationPhase::Capture); - 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 - { + let controller = Rc::clone(self); + scroll_controller.connect_scroll(move |_, _, delta_y| { + if controller.view_mode() == ViewMode::Continuous || delta_y == 0.0 { return glib::Propagation::Proceed; } controller.navigate(delta_y > 0.0); @@ -915,373 +267,31 @@ impl ViewerController { }); self.stack.add_controller(scroll_controller); - 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 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; + 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 } - if !controller.window.is_fullscreen() { - controller.hide_seek(); + gdk::Key::Right | gdk::Key::Page_Down | gdk::Key::space => { + controller.navigate(true); + glib::Propagation::Stop } - 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(); + _ 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); } fn toggle_fullscreen(&self) { @@ -1292,88 +302,12 @@ 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, case_insensitive_sort).map_err(|error| format!("{error:#}")), - ); + let _ = sender.send(list_pages(&path).map_err(|error| format!("{error:#}"))); }); let controller = Rc::downgrade(self); glib::timeout_add_local(Duration::from_millis(20), move || { @@ -1398,7 +332,6 @@ impl ViewerController { .set_text("지원하는 이미지가 ZIP 파일에 없습니다."); } Ok(pages) => { - let page_count = pages.len(); let saved = self .database .load_progress(&self.source.source_uri) @@ -1410,9 +343,6 @@ 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(); } @@ -1447,7 +377,6 @@ impl ViewerController { frame, picture, ratio: default_ratio, - animation_generation: Rc::new(AnimationState::default()), }); } let mut state = self.state.borrow_mut(); @@ -1478,133 +407,22 @@ impl ViewerController { ViewMode::Continuous => self.stack.set_visible_child_name("continuous"), _ => self.stack.set_visible_child_name("single"), } - 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(); - } + 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(); } 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 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 { + fn navigate(self: &Rc, forward: bool) { let step = if self.view_mode() == ViewMode::TwoPage { 2 } else { @@ -1612,7 +430,7 @@ impl ViewerController { }; let mut state = self.state.borrow_mut(); if state.pages.is_empty() { - return false; + return; } let next = if forward { state.anchor.saturating_add(step).min(state.pages.len() - 1) @@ -1620,38 +438,14 @@ impl ViewerController { state.anchor.saturating_sub(step) }; if next == state.anchor { - return false; + return; } 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) { @@ -1667,24 +461,6 @@ 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() { @@ -1797,13 +573,21 @@ impl ViewerController { Ok(page) => { let ratio = page.width as f32 / page.height as f32; decoded_ratio = Some(ratio); - let (frames, cost) = texture_frames(page); + 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, + ); state.access_clock = state.access_clock.wrapping_add(1); let last_used = state.access_clock; state.cache.insert( index, CachedPage { - frames, + texture, cost, last_used, }, @@ -1824,13 +608,11 @@ impl ViewerController { }; if let Some(frame) = frame { frame.set_ratio(ratio); - self.resize_continuous_rows(); + frame.set_size_request(-1, row_height(self.continuous_content_width(), ratio)); } } self.evict_cache(); - if self.visible_indices().contains(&index) { - self.render_loaded_pages(); - } + self.render_loaded_pages(); self.update_spinner(); self.pump_requests(); } @@ -1847,159 +629,33 @@ impl ViewerController { fn render_single(&self, index: usize) { let state = self.state.borrow(); - let frames = state.cache.get(&index).map(|page| Rc::clone(&page.frames)); + self.single_picture + .set_paintable(state.cache.get(&index).map(|page| &page.texture)); 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)) - .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); + let first = indices.first().and_then(|index| state.cache.get(index)); + let second = indices.get(1).and_then(|index| state.cache.get(index)); if self.direction_dropdown.selected() == 1 { - set_picture_animation(&self.left_picture, second, &self.left_animation_generation); - set_picture_animation(&self.right_picture, first, &self.right_animation_generation); + self.left_picture + .set_paintable(second.map(|page| &page.texture)); + self.right_picture + .set_paintable(first.map(|page| &page.texture)); } else { - set_picture_animation(&self.left_picture, first, &self.left_animation_generation); - set_picture_animation( - &self.right_picture, - second, - &self.right_animation_generation, - ); + self.left_picture + .set_paintable(first.map(|page| &page.texture)); + self.right_picture + .set_paintable(second.map(|page| &page.texture)); } - self.status_label.set_text(&status); - self.resize_spread_pictures(); + self.status_label.set_text( + &indices + .iter() + .map(|index| state.pages[*index].name.as_str()) + .collect::>() + .join(" · "), + ); } fn render_continuous(&self, visible: &[usize]) { @@ -2008,36 +664,24 @@ impl ViewerController { let old_bound = state.continuous_bound.clone(); let mut updates = Vec::new(); for index in old_bound.difference(&new_bound) { - let row = &state.continuous_rows[*index]; - updates.push(( - row.picture.clone(), - None, - Rc::clone(&row.animation_generation), - )); + updates.push((state.continuous_rows[*index].picture.clone(), None)); } for index in &new_bound { state.access_clock = state.access_clock.wrapping_add(1); let clock = state.access_clock; - let frames = state.cache.get_mut(index).map(|page| { + let texture = state.cache.get_mut(index).map(|page| { page.last_used = clock; - Rc::clone(&page.frames) + page.texture.clone() }); - 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), - )); - } + updates.push((state.continuous_rows[*index].picture.clone(), texture)); } state.continuous_bound = new_bound; let status = visible .first() .map(|index| state.pages[*index].name.clone()); drop(state); - for (picture, frames, generation) in updates { - set_picture_animation(&picture, frames, &generation); + for (picture, texture) in updates { + picture.set_paintable(texture.as_ref()); } if let Some(status) = status { self.status_label.set_text(&status); @@ -2045,16 +689,13 @@ impl ViewerController { } fn continuous_scrolled(self: &Rc) { - let pages_empty = self.state.borrow().pages.is_empty(); - if self.view_mode() != ViewMode::Continuous || pages_empty { + if self.view_mode() != ViewMode::Continuous || self.state.borrow().pages.is_empty() { return; } let visible = self.visible_indices(); let new_anchor = visible.first().copied(); - 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) { + let changed = new_anchor.is_some_and(|index| index != self.state.borrow().anchor); + if let Some(index) = new_anchor { self.state.borrow_mut().anchor = index; } self.render_continuous(&visible); @@ -2114,28 +755,16 @@ impl ViewerController { } fn scroll_to_anchor(&self) { - let frame = { - let state = self.state.borrow(); - let Some(row) = state.continuous_rows.get(state.anchor) else { - return; - }; - row.frame.clone() + let state = self.state.borrow(); + let Some(row) = state.continuous_rows.get(state.anchor) else { + return; }; - let Some(bounds) = frame.compute_bounds(&self.continuous_box) else { + let Some(bounds) = row.frame.compute_bounds(&self.continuous_box) else { return; }; let adjustment = self.continuous_scrolled.vadjustment(); let maximum = (adjustment.upper() - adjustment.page_size()).max(adjustment.lower()); - 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); + adjustment.set_value(f64::from(bounds.y()).clamp(adjustment.lower(), maximum)); } fn clear_continuous_paintables(&self) { @@ -2143,26 +772,16 @@ impl ViewerController { let indices: Vec<_> = state.continuous_bound.drain().collect(); let pictures: Vec<_> = indices .into_iter() - .map(|index| { - let row = &state.continuous_rows[index]; - (row.picture.clone(), Rc::clone(&row.animation_generation)) - }) + .map(|index| state.continuous_rows[index].picture.clone()) .collect(); drop(state); - for (picture, generation) in pictures { - set_picture_animation(&picture, None, &generation); + for picture in pictures { + picture.set_paintable(gdk::Paintable::NONE); } } fn resize_continuous_rows(&self) { - 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 width = self.continuous_content_width(); let rows: Vec<_> = self .state .borrow() @@ -2171,13 +790,12 @@ impl ViewerController { .map(|row| (row.frame.clone(), row.ratio)) .collect(); for (frame, ratio) in rows { - frame.set_hexpand(!zoomed); - frame.set_size_request(if zoomed { width } else { -1 }, row_height(width, ratio)); + frame.set_size_request(-1, row_height(width, ratio)); } } fn continuous_content_width(&self) -> i32 { - continuous_content_width(self.stack.width()) + (self.continuous_scrolled.allocated_width() - 24).max(320) } fn evict_cache(&self) { @@ -2220,1554 +838,26 @@ impl ViewerController { } fn update_navigation(&self) { - let (count, anchor) = { - let state = self.state.borrow(); - (state.pages.len(), state.anchor) - }; + let state = self.state.borrow(); + let count = state.pages.len(); if count == 0 { self.page_label.set_text("- / -"); return; } let visible = self.visible_indices(); - let end = visible.last().copied().unwrap_or(anchor) + 1; + let end = visible.last().copied().unwrap_or(state.anchor) + 1; if visible.len() > 1 && self.view_mode() == ViewMode::TwoPage { self.page_label - .set_text(&format!("{}-{end} / {count}", anchor + 1)); + .set_text(&format!("{}-{end} / {count}", state.anchor + 1)); } else { self.page_label - .set_text(&format!("{} / {count}", anchor + 1)); + .set_text(&format!("{} / {count}", state.anchor + 1)); } - self.previous_button.set_sensitive(anchor > 0); + self.previous_button.set_sensitive(state.anchor > 0); self.next_button.set_sensitive(end < 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, + self.shift_back_button.set_sensitive(state.anchor > 0); + self.shift_forward_button + .set_sensitive(state.anchor + 1 < count); } } @@ -3779,58 +869,6 @@ 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(); @@ -3847,166 +885,6 @@ 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(); @@ -4040,157 +918,6 @@ 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::*; @@ -4210,25 +937,6 @@ 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] @@ -4242,19 +950,6 @@ 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]); @@ -4265,223 +960,4 @@ 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 f4830f5..1d1be43 100644 --- a/src/window.rs +++ b/src/window.rs @@ -1,48 +1,25 @@ -use std::cell::{Cell, RefCell}; -use std::fs; -use std::io::Read; -use std::path::{Path, PathBuf}; -use std::process::Command; +use std::cell::RefCell; +use std::path::PathBuf; use std::rc::Rc; -use std::sync::mpsc; -use std::thread; use std::time::{Duration, Instant}; -use anyhow::{Context, Result, bail}; +use anyhow::Result; 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, classify_file, sort_entries, -}; -use crate::config::{ - AppConfig, FavoriteEntry, LocationKind, LocationProfile, RecentFileEntry, ViewerMode, -}; +use crate::browser::{BrowserEntry, EntryKind, SortDirection, SortField, sort_entries}; +use crate::config::{AppConfig, LocationKind, LocationProfile}; use crate::database::Database; use crate::source::{ - 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, + display_remote_uri, enumerate_directory, file_from_user_input, is_within_root, mount_operation, + parent_within_root, root_file, validate_profile, }; +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, } @@ -66,10 +43,6 @@ 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); @@ -86,14 +59,11 @@ 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() @@ -118,8 +88,6 @@ 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("더 많은 페이지를 미리 디코딩하여 메모리에 유지") @@ -127,17 +95,15 @@ 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_selection = gtk::SingleSelection::new(None::); - let list_view = - gtk::ListView::new(Some(list_selection.clone()), None::); - list_view.set_single_click_activate(false); + let list_box = gtk::ListBox::new(); + list_box.set_selection_mode(gtk::SelectionMode::Single); + list_box.set_activate_on_single_click(false); let scrolled = gtk::ScrolledWindow::builder() .vexpand(true) - .child(&list_view) + .child(&list_box) .build(); let status_label = gtk::Label::builder().xalign(0.0).build(); @@ -150,23 +116,17 @@ 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_view, - list_selection, + list_box, 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(), @@ -181,8 +141,6 @@ 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(); @@ -191,10 +149,8 @@ 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 }) } @@ -202,18 +158,10 @@ 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, @@ -225,35 +173,22 @@ 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_view: gtk::ListView, - list_selection: gtk::SingleSelection, + list_box: gtk::ListBox, 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 { @@ -263,7 +198,6 @@ 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); @@ -278,9 +212,6 @@ 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)); @@ -295,46 +226,6 @@ 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()); @@ -345,87 +236,19 @@ impl BrowserController { self.direction_button .connect_toggled(move |_| controller.change_sort_direction()); let controller = Rc::clone(self); - 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)); + self.list_box + .connect_row_activated(move |_, row| controller.activate_row(row.index())); let key_controller = gtk::EventControllerKey::new(); let controller = Rc::clone(self); - 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); + key_controller + .connect_key_pressed(move |_, key, _, modifiers| controller.typeahead(key, modifiers)); + self.list_box.add_controller(key_controller); 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 { @@ -434,46 +257,22 @@ 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 mut names: Vec<_> = profiles + let names: Vec<_> = profiles .iter() - .map(|profile| profile.name.clone()) + .map(|profile| profile.name.as_str()) .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 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(); + let editable = profile_index > 0 && profile_index <= self.config.borrow().locations.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; }; @@ -482,13 +281,9 @@ 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(); } @@ -496,169 +291,8 @@ 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) { - if self.state.borrow().mode != BrowserMode::Directory { - return; - } - let profile = self.current_profile(); + let profile = self.profiles()[self.state.borrow().profile_index].clone(); 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); @@ -672,9 +306,6 @@ 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); @@ -686,49 +317,29 @@ 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(); ( - state - .favorite_profile - .clone() - .unwrap_or_else(|| self.profiles()[state.profile_index].clone()), + 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); - let task = glib::MainContext::default().spawn_local(async move { + glib::MainContext::default().spawn_local(async move { let result = enumerate_directory(&profile, &uri, &operation, move |count| { let Some(controller) = progress_controller.upgrade() else { return; }; - let state = controller.state.borrow(); - if state.generation == generation && state.mode == BrowserMode::Directory { + if controller.state.borrow().generation == generation { controller.status_label.set_text(&format!( "폴더를 불러오는 중... ({count}개의 파일/폴더를 읽음)" )); @@ -738,10 +349,7 @@ impl BrowserController { let Some(controller) = controller.upgrade() else { return; }; - let state = controller.state.borrow(); - let stale = state.generation != generation || state.mode != BrowserMode::Directory; - drop(state); - if stale { + if controller.state.borrow().generation != generation { return; } match result { @@ -752,42 +360,26 @@ 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| browser_search_match(entry, query.as_str())) + .filter(|entry| entry.name.to_lowercase().contains(query.as_str())) .cloned() .collect(); - if state.mode != BrowserMode::Recent { - sort_entries( - &mut visible_entries, - state.sort_field, - state.sort_direction, - case_insensitive, - ); + sort_entries(&mut visible_entries, state.sort_field, state.sort_direction); + for entry in &visible_entries { + self.list_box.append(&entry_row(entry)); } 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}개 항목")); } @@ -802,26 +394,14 @@ impl BrowserController { if modifiers.intersects(blocked) { return glib::Propagation::Proceed; } - 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 { + let Some(character) = key + .to_unicode() + .filter(|character| character.is_alphanumeric()) + else { return glib::Propagation::Proceed; }; - let selected = (self.list_selection.selected() != gtk::INVALID_LIST_POSITION) - .then(|| self.list_selection.selected() as usize); + let selected = self.list_box.selected_row().map(|row| row.index() as usize); let now = Instant::now(); let mut state = self.state.borrow_mut(); if state @@ -844,15 +424,14 @@ impl BrowserController { 0 }; let found = find_prefix_index(&state.visible_entries, &query, start); - let found_name = found.map(|index| state.visible_entries[index].display_name().to_owned()); + let found_name = found.map(|index| state.visible_entries[index].name.clone()); drop(state); - if let Some(index) = found { - self.list_view.scroll_to( - index as u32, - gtk::ListScrollFlags::FOCUS | gtk::ListScrollFlags::SELECT, - None, - ); + 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(); self.status_label.set_text(&format!( "'{query}'로 이동: {}", found_name.unwrap_or_default() @@ -864,14 +443,6 @@ 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, @@ -893,7 +464,7 @@ impl BrowserController { self.render(); } - fn activate_row(self: &Rc, index: u32) { + fn activate_row(self: &Rc, index: i32) { let Some(entry) = self .state .borrow() @@ -903,869 +474,44 @@ 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 | 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 => {} + EntryKind::ZipArchive => self.open_archive(entry), } } - 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(); + fn open_archive(self: &Rc, entry: BrowserEntry) { self.status_label.set_text("ZIP 파일 다운로드 준비 중..."); - 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 progress_label = self.status_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| { - 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); - } - } - }, - ); - } - - 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 { + move |result| match result { + Ok(source) => { + controller.status_label.set_text("다운로드 완료"); + let Some(application) = controller.window.application() 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())); + ViewerWindow::open( + &application, + source, + Rc::clone(&controller.database), + controller.config.borrow().fast_image_loading, + ); } + Err(error) => controller.status_label.set_text(&format!("{error:#}")), }, ); } - 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; @@ -1796,153 +542,6 @@ 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()); @@ -2113,202 +712,6 @@ 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 { @@ -2331,37 +734,6 @@ 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( @@ -2370,53 +742,34 @@ fn display_uri(uri: &str) -> String { ) } -fn entry_content() -> gtk::Box { +fn entry_row(entry: &BrowserEntry) -> gtk::ListBoxRow { + let row = gtk::ListBoxRow::new(); 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); - content.append(>k::Image::new()); + 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::Label::builder() + .label(&entry.name) .hexpand(true) .xalign(0.0) .ellipsize(gtk::pango::EllipsizeMode::Middle) .build(), ); - for _ in 0..2 { - let label = gtk::Label::new(None); + for time in [entry.modified, entry.created] { + let label = gtk::Label::new(Some(&format_time(time))); label.set_width_chars(17); label.set_xalign(1.0); content.append(&label); } - 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::() else { - return; - }; - name.set_text(entry.display_name()); - let Some(modified) = name.next_sibling().and_downcast::() else { - return; - }; - modified.set_text(&format_time(entry.modified)); - let Some(created) = modified.next_sibling().and_downcast::() else { - return; - }; - created.set_text(&format_time(entry.created)); + row.set_child(Some(&content)); + row } fn format_time(time: Option) -> String { @@ -2434,170 +787,7 @@ fn find_prefix_index(entries: &[BrowserEntry], query: &str, start: usize) -> Opt let query = query.to_lowercase(); (0..entries.len()) .map(|offset| (start + offset) % entries.len()) - .find(|index| { - entries[*index] - .display_name() - .to_lowercase() - .starts_with(&query) - }) -} - -fn navigable_sibling(current: EntryKind, candidate: EntryKind) -> bool { - current.is_viewable() && candidate.is_viewable() -} - -fn browser_search_match(entry: &BrowserEntry, lowercase_query: &str) -> bool { - lowercase_query.is_empty() || entry.name.to_lowercase().contains(lowercase_query) -} - -fn special_browser_mode(selected: u32, profile_count: usize) -> Option { - if selected == gtk::INVALID_LIST_POSITION { - return None; - } - match selected as usize { - index if index == profile_count => Some(BrowserMode::Favorites), - index if index == profile_count + 1 => Some(BrowserMode::Recent), - _ => None, - } -} - -fn sorted_navigable_entries( - entries: &[BrowserEntry], - current_kind: EntryKind, - sort_field: SortField, - sort_direction: SortDirection, - case_insensitive: bool, -) -> Vec { - let mut siblings = entries - .iter() - .filter(|entry| navigable_sibling(current_kind, entry.kind)) - .cloned() - .collect::>(); - sort_entries(&mut siblings, sort_field, sort_direction, case_insensitive); - siblings -} - -fn sorted_navigable_selection( - entries: &[BrowserEntry], - selected_uri: &str, - sort_field: SortField, - sort_direction: SortDirection, - case_insensitive: bool, -) -> Option<(Vec, usize)> { - let entries = sorted_navigable_entries( - entries, - EntryKind::Image, - sort_field, - sort_direction, - case_insensitive, - ); - let selected = entries.iter().position(|entry| entry.uri == selected_uri)?; - Some((entries, selected)) -} - -fn favorite_browser_entry(favorite: &FavoriteEntry) -> BrowserEntry { - BrowserEntry { - uri: favorite.uri.clone(), - name: favorite.name.clone(), - list_name: None, - kind: if favorite.is_directory { - EntryKind::Directory - } else { - classify_file(Path::new(&favorite.name)) - }, - size: None, - modified: None, - created: None, - etag: None, - } -} - -fn recent_file_browser_entry(recent: &RecentFileEntry) -> BrowserEntry { - BrowserEntry { - uri: recent.uri.clone(), - name: recent.name.clone(), - list_name: None, - kind: classify_file(Path::new(&recent.name)), - size: None, - modified: None, - created: None, - etag: None, - } -} - -fn record_recent_file(config: &mut AppConfig, entry: &BrowserEntry, profile: &LocationProfile) { - config.recent_files.retain(|recent| recent.uri != entry.uri); - config.recent_files.insert( - 0, - RecentFileEntry { - name: entry.name.clone(), - uri: entry.uri.clone(), - profile: profile.clone(), - }, - ); - config.recent_files.truncate(RECENT_FILE_LIMIT); -} - -fn show_viewer_loading( - window: >k::ApplicationWindow, - file_name: &str, - status: &str, -) -> gtk::Label { - set_viewer_loading(window, true); - window.set_title(Some(file_name)); - let header = gtk::HeaderBar::new(); - header.set_title_widget(Some(>k::Label::new(Some(file_name)))); - set_viewer_header(window, &header); - - let content = gtk::Box::new(gtk::Orientation::Vertical, 12); - content.set_halign(gtk::Align::Center); - content.set_valign(gtk::Align::Center); - content.set_hexpand(true); - content.set_vexpand(true); - let spinner = gtk::Spinner::new(); - spinner.set_spinning(true); - let name_label = gtk::Label::new(Some(file_name)); - name_label.add_css_class("title-2"); - name_label.set_ellipsize(gtk::pango::EllipsizeMode::Middle); - name_label.set_max_width_chars(60); - let status_label = gtk::Label::new(Some(status)); - content.append(&spinner); - content.append(&name_label); - content.append(&status_label); - window.set_child(Some(&content)); - status_label -} - -fn download_part_path(final_path: &std::path::Path) -> PathBuf { - final_path.with_file_name(format!( - "{}.part", - final_path - .file_name() - .map_or_else(|| "download".into(), |name| name.to_string_lossy()) - )) -} - -fn toggle_favorite_entry( - config: &mut AppConfig, - entry: &BrowserEntry, - profile: &LocationProfile, -) -> bool { - if let Some(index) = config - .favorites - .iter() - .position(|favorite| favorite.uri == entry.uri) - { - config.favorites.remove(index); - false - } else { - config.favorites.push(FavoriteEntry { - name: entry.name.clone(), - uri: entry.uri.clone(), - is_directory: entry.kind == EntryKind::Directory, - profile: profile.clone(), - }); - true - } + .find(|index| entries[*index].name.to_lowercase().starts_with(&query)) } #[cfg(test)] @@ -2608,7 +798,6 @@ mod tests { BrowserEntry { uri: format!("file:///{name}"), name: name.into(), - list_name: None, kind: EntryKind::Directory, size: None, modified: None, @@ -2617,12 +806,6 @@ mod tests { } } - fn media_entry(name: &str) -> BrowserEntry { - let mut entry = entry(name); - entry.kind = EntryKind::Image; - entry - } - #[test] fn typeahead_matches_case_insensitively() { let entries = [entry("Alpha"), entry("beta"), entry("Bravo")]; @@ -2636,276 +819,4 @@ mod tests { assert_eq!(find_prefix_index(&entries, "b", 2), Some(2)); assert_eq!(find_prefix_index(&entries, "b", 3), Some(1)); } - - #[test] - fn viewer_navigation_includes_all_viewable_files() { - assert!(navigable_sibling(EntryKind::Image, EntryKind::Video)); - assert!(navigable_sibling(EntryKind::Video, EntryKind::Image)); - assert!(navigable_sibling(EntryKind::Image, EntryKind::ZipArchive)); - assert!(navigable_sibling(EntryKind::ZipArchive, EntryKind::Video)); - assert!(!navigable_sibling(EntryKind::Video, EntryKind::OtherFile)); - assert!(!navigable_sibling(EntryKind::Directory, EntryKind::Image)); - } - - #[test] - fn media_navigation_recalculates_position_for_case_sorting() { - let entries = [media_entry("a2.jpg"), media_entry("A10.jpg")]; - let insensitive = sorted_navigable_entries( - &entries, - EntryKind::Image, - SortField::Name, - SortDirection::Ascending, - true, - ); - let sensitive = sorted_navigable_entries( - &entries, - EntryKind::Image, - SortField::Name, - SortDirection::Ascending, - false, - ); - - assert_eq!(insensitive[0].name, "a2.jpg"); - assert_eq!(sensitive[0].name, "A10.jpg"); - assert_eq!( - insensitive.iter().position(|entry| entry.name == "a2.jpg"), - Some(0) - ); - assert_eq!( - sensitive.iter().position(|entry| entry.name == "a2.jpg"), - Some(1) - ); - } - - #[test] - fn dropped_file_selection_uses_sorted_parent_index() { - let entries = [ - media_entry("page10.jpg"), - entry("folder"), - media_entry("page2.jpg"), - ]; - let selected_uri = entries[0].uri.clone(); - - let (siblings, selected) = sorted_navigable_selection( - &entries, - &selected_uri, - SortField::Name, - SortDirection::Ascending, - true, - ) - .unwrap(); - - assert_eq!(siblings.len(), 2); - assert_eq!(siblings[0].name, "page2.jpg"); - assert_eq!(siblings[selected].name, "page10.jpg"); - } - - #[test] - fn mouse_back_button_matches_standard_x11_button() { - assert_eq!(MOUSE_BACK_BUTTON, 8); - } - - #[test] - fn dropped_directory_creates_local_root_profile() { - let directory = tempfile::tempdir().unwrap(); - let file = gio::File::for_path(directory.path()); - - let profile = local_profile_for_directory(&file).unwrap(); - - assert_eq!(profile.kind, LocationKind::Local); - assert_eq!(Path::new(&profile.address), directory.path()); - assert!(profile.username.is_empty()); - assert!(profile.password.is_empty()); - } - - #[test] - fn browser_search_filters_all_current_directory_entry_kinds() { - let folder = entry("Comics"); - let image = media_entry("cover.jpg"); - - assert!(browser_search_match(&folder, "comic")); - assert!(browser_search_match(&image, "cover")); - assert!(!browser_search_match(&image, "comic")); - assert!(browser_search_match(&image, "")); - let mut nested = media_entry("cover.jpg"); - nested.list_name = Some("Comics/cover.jpg".into()); - assert!(!browser_search_match(&nested, "comic")); - } - - #[test] - fn update_checksum_parser_validates_sha256_text() { - let checksum = - "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789 bundle.tar.gz\n"; - assert_eq!( - parse_update_checksum(checksum).unwrap(), - "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789" - ); - assert!(parse_update_checksum("not-a-checksum").is_err()); - } - - #[test] - fn update_sha256_matches_known_content() { - let directory = tempfile::tempdir().unwrap(); - let file = directory.path().join("content"); - fs::write(&file, b"abc").unwrap(); - assert_eq!( - sha256_file(&file).unwrap(), - "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" - ); - } - - #[test] - fn update_archive_extracts_regular_files_and_rejects_symlinks() { - let directory = tempfile::tempdir().unwrap(); - let valid_archive = directory.path().join("valid.tar.gz"); - { - let file = fs::File::create(&valid_archive).unwrap(); - let encoder = flate2::write::GzEncoder::new(file, flate2::Compression::default()); - let mut archive = tar::Builder::new(encoder); - let content = b"#!/bin/sh\n"; - let mut header = tar::Header::new_gnu(); - header.set_size(content.len() as u64); - header.set_mode(0o755); - header.set_cksum(); - archive - .append_data( - &mut header, - "Comicviewer-latest-x86_64/install-or-update.sh", - &content[..], - ) - .unwrap(); - archive.into_inner().unwrap().finish().unwrap(); - } - let extracted = directory.path().join("valid"); - fs::create_dir(&extracted).unwrap(); - extract_update_archive(&valid_archive, &extracted).unwrap(); - assert!( - extracted - .join("Comicviewer-latest-x86_64/install-or-update.sh") - .is_file() - ); - - let link_archive = directory.path().join("link.tar.gz"); - { - let file = fs::File::create(&link_archive).unwrap(); - let encoder = flate2::write::GzEncoder::new(file, flate2::Compression::default()); - let mut archive = tar::Builder::new(encoder); - let mut header = tar::Header::new_gnu(); - header.set_entry_type(tar::EntryType::Symlink); - header.set_size(0); - header.set_mode(0o777); - header.set_link_name("../../escape").unwrap(); - header.set_cksum(); - archive - .append_data( - &mut header, - "Comicviewer-latest-x86_64/link", - std::io::empty(), - ) - .unwrap(); - archive.into_inner().unwrap().finish().unwrap(); - } - let rejected = directory.path().join("rejected"); - fs::create_dir(&rejected).unwrap(); - assert!(extract_update_archive(&link_archive, &rejected).is_err()); - } - - #[test] - fn favorites_are_rendered_as_browser_paths_and_files() { - let profile = home_profile(); - let folder = favorite_browser_entry(&FavoriteEntry { - name: "Comics".into(), - uri: "file:///tmp/Comics".into(), - is_directory: true, - profile: profile.clone(), - }); - let archive = favorite_browser_entry(&FavoriteEntry { - name: "book.zip".into(), - uri: "file:///tmp/book.zip".into(), - is_directory: false, - profile, - }); - - assert_eq!(folder.kind, EntryKind::Directory); - assert_eq!(archive.kind, EntryKind::ZipArchive); - assert_eq!(special_browser_mode(3, 3), Some(BrowserMode::Favorites)); - assert_eq!(special_browser_mode(4, 3), Some(BrowserMode::Recent)); - assert_eq!(special_browser_mode(2, 3), None); - assert_eq!(special_browser_mode(gtk::INVALID_LIST_POSITION, 3), None); - } - - #[test] - fn recent_files_move_to_front_and_keep_only_100() { - let profile = LocationProfile { - name: "원격".into(), - kind: LocationKind::Sftp, - address: "sftp://example.invalid/comics".into(), - username: "reader".into(), - password: "password".into(), - domain: String::new(), - }; - let mut config = AppConfig::default(); - for index in 0..=RECENT_FILE_LIMIT { - let entry = media_entry(&format!("page{index}.jpg")); - record_recent_file(&mut config, &entry, &profile); - } - assert_eq!(config.recent_files.len(), RECENT_FILE_LIMIT); - assert_eq!(config.recent_files[0].name, "page100.jpg"); - assert!( - !config - .recent_files - .iter() - .any(|recent| recent.name == "page0.jpg") - ); - - let entry = media_entry("page50.jpg"); - record_recent_file(&mut config, &entry, &profile); - assert_eq!(config.recent_files.len(), RECENT_FILE_LIMIT); - assert_eq!(config.recent_files[0].name, "page50.jpg"); - assert_eq!(config.recent_files[0].profile.password, "password"); - } - - #[test] - fn recent_files_support_all_viewer_file_types() { - let profile = home_profile(); - let mut config = AppConfig::default(); - for name in ["book.zip", "page.jpg", "clip.mp4"] { - let mut entry = media_entry(name); - entry.kind = classify_file(Path::new(name)); - record_recent_file(&mut config, &entry, &profile); - } - let kinds = config - .recent_files - .iter() - .map(recent_file_browser_entry) - .map(|entry| entry.kind) - .collect::>(); - assert_eq!( - kinds, - [EntryKind::Video, EntryKind::Image, EntryKind::ZipArchive] - ); - } - - #[test] - fn incomplete_download_uses_distinct_suffix() { - assert_eq!( - download_part_path(std::path::Path::new("/tmp/만화.zip")), - PathBuf::from("/tmp/만화.zip.part") - ); - } - - #[test] - fn favorite_toggle_adds_and_removes_the_same_uri() { - let mut config = AppConfig::default(); - let entry = entry("Comics"); - let profile = home_profile(); - - assert!(toggle_favorite_entry(&mut config, &entry, &profile)); - assert_eq!(config.favorites.len(), 1); - assert!(config.favorites[0].is_directory); - assert_eq!(config.favorites[0].profile.address, profile.address); - - assert!(!toggle_favorite_entry(&mut config, &entry, &profile)); - assert!(config.favorites.is_empty()); - } } diff --git a/src/zip_cache.rs b/src/zip_cache.rs index ec5fd61..d7bff44 100644 --- a/src/zip_cache.rs +++ b/src/zip_cache.rs @@ -1,4 +1,4 @@ -use std::cell::{Cell, RefCell}; +use std::cell::RefCell; use std::collections::HashMap; use std::fs::{self, File}; use std::path::{Path, PathBuf}; @@ -17,25 +17,16 @@ use crate::browser::BrowserEntry; pub struct ArchiveSource { pub local_path: PathBuf, pub source_uri: String, - pub display_name: String, _temporary: Option>, _pin: Option>, } pub struct ZipCache { directory: PathBuf, - quota_bytes: Cell, + quota_bytes: u64, pinned: RefCell>, } -#[derive(Debug, Default, PartialEq, Eq)] -pub struct CacheCleanupReport { - pub removed_files: usize, - pub removed_bytes: u64, - pub retained_open_files: usize, - pub remaining_bytes: u64, -} - struct CachePin { path: PathBuf, cache: Weak, @@ -45,18 +36,12 @@ impl Drop for CachePin { fn drop(&mut self) { if let Some(cache) = self.cache.upgrade() { let mut pinned = cache.pinned.borrow_mut(); - let mut released = false; if let Some(count) = pinned.get_mut(&self.path) { *count -= 1; if *count == 0 { pinned.remove(&self.path); - released = true; } } - drop(pinned); - if released { - let _ = cache.enforce_quota(None); - } } } } @@ -66,24 +51,18 @@ impl ZipCache { fs::create_dir_all(&directory)?; for entry in fs::read_dir(&directory)? { let path = entry?.path(); - let incomplete_download = path + if path .extension() - .is_some_and(|extension| extension == "part"); - let stale_temporary = path - .file_name() - .and_then(|name| name.to_str()) - .is_some_and(|name| name.starts_with("temporary-")); - if incomplete_download || stale_temporary { + .is_some_and(|extension| extension == "part") + { let _ = fs::remove_file(path); } } - let cache = Rc::new(Self { + Ok(Rc::new(Self { directory, - quota_bytes: Cell::new(quota_gb.saturating_mul(1024 * 1024 * 1024)), + quota_bytes: quota_gb.saturating_mul(1024 * 1024 * 1024), pinned: RefCell::new(HashMap::new()), - }); - cache.enforce_quota(None)?; - Ok(cache) + })) } pub fn prepare(self: &Rc, entry: BrowserEntry, progress: P, callback: F) @@ -96,63 +75,31 @@ impl ZipCache { callback(Ok(ArchiveSource { local_path: path, source_uri: entry.uri, - display_name: entry.name, _temporary: None, _pin: None, })); return; } - let quota_bytes = self.quota_bytes.get(); - if quota_bytes == 0 || entry.size.is_some_and(|size| size > quota_bytes) { - self.download_temporary(source, entry, true, progress, callback); + if self.quota_bytes == 0 || entry.size.is_some_and(|size| size > self.quota_bytes) { + self.download_temporary(source, entry.uri, entry.size, progress, callback); } else { self.download_persistent(source, entry, progress, callback); } } - pub fn prepare_media(self: &Rc, entry: BrowserEntry, progress: P, callback: F) - where - F: FnOnce(Result) + 'static, - P: FnMut(i64, i64) + 'static, - { - let source = gio::File::for_uri(&entry.uri); - if let Some(path) = native_path(&source) { - callback(Ok(ArchiveSource { - local_path: path, - source_uri: entry.uri, - display_name: entry.name, - _temporary: None, - _pin: None, - })); - return; - } - self.download_temporary(source, entry, false, progress, callback); - } - fn download_temporary( self: &Rc, source: gio::File, - entry: BrowserEntry, - validate_zip: bool, + source_uri: String, + expected_size: Option, progress: P, callback: F, ) where F: FnOnce(Result) + 'static, P: FnMut(i64, i64) + 'static, { - let suffix = Path::new(&entry.name) - .extension() - .and_then(|extension| extension.to_str()) - .map_or_else( - || ".part".to_owned(), - |extension| format!(".part.{extension}"), - ); - let temporary = match tempfile::Builder::new() - .prefix("temporary-") - .suffix(&suffix) - .tempfile_in(&self.directory) - { + let temporary = match tempfile::Builder::new().suffix(".zip.part").tempfile() { Ok(file) => Rc::new(file.into_temp_path()), Err(error) => { callback(Err(error.into())); @@ -161,7 +108,6 @@ impl ZipCache { }; let destination = gio::File::for_path(temporary.as_ref()); let retained = Rc::clone(&temporary); - let expected_size = entry.size; source.copy_async( &destination, gio::FileCopyFlags::OVERWRITE, @@ -170,14 +116,10 @@ impl ZipCache { Some(Box::new(progress)), move |result| { callback(result.map_err(Into::into).and_then(|()| { - validate_size(retained.as_ref(), expected_size)?; - if validate_zip { - validate_zip_file(retained.as_ref())?; - } + validate_download(retained.as_ref(), expected_size)?; Ok(ArchiveSource { local_path: retained.to_path_buf(), - source_uri: entry.uri, - display_name: entry.name, + source_uri, _temporary: Some(retained), _pin: None, }) @@ -201,19 +143,13 @@ impl ZipCache { if final_path.is_file() { if validate_download(&final_path, entry.size).is_ok() { let _ = filetime::set_file_mtime(&final_path, FileTime::now()); - callback(Ok(self.lease(final_path, entry.uri, entry.name))); + callback(Ok(self.lease(final_path, entry.uri))); return; } let _ = fs::remove_file(&final_path); } let part_path = self.directory.join(format!("{key}.part")); - if let Some(required_bytes) = entry.size - && let Err(error) = self.make_room_for(required_bytes) - { - callback(Err(error)); - return; - } let destination = gio::File::for_path(&part_path); let cache = Rc::clone(self); source.copy_async( @@ -231,8 +167,8 @@ impl ZipCache { final_path.display() ) })?; - cache.enforce_quota(Some(&final_path))?; - Ok(cache.lease(final_path, entry.uri, entry.name)) + cache.enforce_quota(&final_path)?; + Ok(cache.lease(final_path, entry.uri)) }); if result.is_err() { let _ = fs::remove_file(&part_path); @@ -242,35 +178,11 @@ impl ZipCache { ); } - pub fn clear_persistent(&self) -> Result { - self.cleanup_to_limit(0, None) - } - - fn make_room_for(&self, required_bytes: u64) -> Result<()> { - let limit = self.quota_bytes.get().saturating_sub(required_bytes); - let report = self.cleanup_to_limit(limit, None)?; - if report.remaining_bytes > limit { - bail!("열려 있는 ZIP 때문에 다운로드에 필요한 캐시 공간을 확보할 수 없습니다"); - } - Ok(()) - } - - fn enforce_quota(&self, protected: Option<&Path>) -> Result { - self.cleanup_to_limit(self.quota_bytes.get(), protected) - } - - fn cleanup_to_limit(&self, limit: u64, protected: Option<&Path>) -> Result { + fn enforce_quota(&self, protected: &Path) -> Result<()> { let mut files = Vec::new(); let mut total = 0_u64; for entry in fs::read_dir(&self.directory)? { let path = entry?.path(); - if path - .file_name() - .and_then(|name| name.to_str()) - .is_some_and(|name| name.starts_with("temporary-")) - { - continue; - } if path.extension().is_none_or(|extension| extension != "zip") { continue; } @@ -279,39 +191,25 @@ impl ZipCache { files.push((metadata.modified().ok(), metadata.len(), path)); } files.sort_by_key(|(modified, _, path)| (*modified, path.clone())); - let mut report = CacheCleanupReport::default(); for (_, size, path) in files { - if total <= limit { + if total <= self.quota_bytes { break; } - if protected == Some(path.as_path()) { - continue; + if path != protected + && !self.pinned.borrow().contains_key(&path) + && fs::remove_file(&path).is_ok() + { + total = total.saturating_sub(size); } - if self.pinned.borrow().contains_key(&path) { - report.retained_open_files += 1; - continue; - } - fs::remove_file(&path) - .with_context(|| format!("캐시 파일을 삭제할 수 없습니다: {}", path.display()))?; - total = total.saturating_sub(size); - report.removed_files += 1; - report.removed_bytes = report.removed_bytes.saturating_add(size); } - report.remaining_bytes = total; - Ok(report) + Ok(()) } - fn lease( - self: &Rc, - path: PathBuf, - source_uri: String, - display_name: String, - ) -> ArchiveSource { + fn lease(self: &Rc, path: PathBuf, source_uri: String) -> ArchiveSource { *self.pinned.borrow_mut().entry(path.clone()).or_default() += 1; ArchiveSource { local_path: path.clone(), source_uri, - display_name, _temporary: None, _pin: Some(Rc::new(CachePin { path, @@ -326,11 +224,6 @@ fn native_path(file: &gio::File) -> Option { } fn validate_download(path: &Path, expected_size: Option) -> Result<()> { - validate_size(path, expected_size)?; - validate_zip_file(path) -} - -fn validate_size(path: &Path, expected_size: Option) -> Result<()> { let actual_size = fs::metadata(path)?.len(); if let Some(expected_size) = expected_size && actual_size != expected_size @@ -339,10 +232,6 @@ fn validate_size(path: &Path, expected_size: Option) -> Result<()> { "다운로드 크기가 원본과 다릅니다: 예상 {expected_size}바이트, 실제 {actual_size}바이트" ); } - Ok(()) -} - -fn validate_zip_file(path: &Path) -> Result<()> { let file = File::open(path)?; zip::ZipArchive::new(file).context("다운로드된 파일이 올바른 ZIP이 아닙니다")?; Ok(()) @@ -375,7 +264,6 @@ mod tests { let mut entry = BrowserEntry { uri: "sftp://example.invalid/a.zip".into(), name: "a.zip".into(), - list_name: None, kind: EntryKind::ZipArchive, size: Some(10), modified: None, @@ -415,113 +303,18 @@ mod tests { fs::write(&second, [0_u8; 8]).unwrap(); let cache = Rc::new(ZipCache { directory: directory.path().to_path_buf(), - quota_bytes: Cell::new(8), + quota_bytes: 8, pinned: RefCell::new(HashMap::new()), }); - let lease = cache.lease( - first.clone(), - "file:///first.zip".into(), - "first.zip".into(), - ); - cache.enforce_quota(Some(&second)).unwrap(); + let lease = cache.lease(first.clone(), "file:///first.zip".into()); + cache.enforce_quota(&second).unwrap(); assert!(first.exists()); assert!(second.exists()); drop(lease); - cache.enforce_quota(Some(&second)).unwrap(); + cache.enforce_quota(&second).unwrap(); assert!(!first.exists()); assert!(second.exists()); } - - #[test] - fn lru_removes_oldest_cache_file_first() { - let directory = tempfile::tempdir().unwrap(); - let oldest = directory.path().join("oldest.zip"); - let newest = directory.path().join("newest.zip"); - fs::write(&oldest, [0_u8; 8]).unwrap(); - fs::write(&newest, [0_u8; 8]).unwrap(); - filetime::set_file_mtime(&oldest, FileTime::from_unix_time(1, 0)).unwrap(); - filetime::set_file_mtime(&newest, FileTime::from_unix_time(2, 0)).unwrap(); - let cache = ZipCache { - directory: directory.path().to_path_buf(), - quota_bytes: Cell::new(8), - pinned: RefCell::new(HashMap::new()), - }; - - let report = cache.enforce_quota(None).unwrap(); - - assert_eq!(report.removed_files, 1); - assert!(!oldest.exists()); - assert!(newest.exists()); - } - - #[test] - fn download_reserves_space_before_writing() { - let directory = tempfile::tempdir().unwrap(); - let oldest = directory.path().join("oldest.zip"); - let newest = directory.path().join("newest.zip"); - fs::write(&oldest, [0_u8; 8]).unwrap(); - fs::write(&newest, [0_u8; 8]).unwrap(); - filetime::set_file_mtime(&oldest, FileTime::from_unix_time(1, 0)).unwrap(); - filetime::set_file_mtime(&newest, FileTime::from_unix_time(2, 0)).unwrap(); - let cache = ZipCache { - directory: directory.path().to_path_buf(), - quota_bytes: Cell::new(16), - pinned: RefCell::new(HashMap::new()), - }; - - cache.make_room_for(8).unwrap(); - - assert!(!oldest.exists()); - assert!(newest.exists()); - } - - #[test] - fn zero_quota_clears_existing_cache_on_startup() { - let directory = tempfile::tempdir().unwrap(); - let cached = directory.path().join("cached.zip"); - fs::write(&cached, [0_u8; 8]).unwrap(); - - let _cache = ZipCache::new(directory.path().to_path_buf(), 0).unwrap(); - - assert!(!cached.exists()); - } - - #[test] - fn startup_removes_stale_temporary_downloads() { - let directory = tempfile::tempdir().unwrap(); - let temporary = directory.path().join("temporary-abcd.part.mp4"); - fs::write(&temporary, [0_u8; 8]).unwrap(); - - let _cache = ZipCache::new(directory.path().to_path_buf(), 10).unwrap(); - - assert!(!temporary.exists()); - } - - #[test] - fn manual_clear_keeps_open_archives() { - let directory = tempfile::tempdir().unwrap(); - let open = directory.path().join("open.zip"); - let unused = directory.path().join("unused.zip"); - let temporary = directory.path().join("temporary-download.part.zip"); - fs::write(&open, [0_u8; 8]).unwrap(); - fs::write(&unused, [0_u8; 8]).unwrap(); - fs::write(&temporary, [0_u8; 8]).unwrap(); - let cache = Rc::new(ZipCache { - directory: directory.path().to_path_buf(), - quota_bytes: Cell::new(16), - pinned: RefCell::new(HashMap::new()), - }); - let lease = cache.lease(open.clone(), "file:///open.zip".into(), "open.zip".into()); - - let report = cache.clear_persistent().unwrap(); - - assert_eq!(report.removed_files, 1); - assert_eq!(report.retained_open_files, 1); - assert!(open.exists()); - assert!(!unused.exists()); - assert!(temporary.exists()); - drop(lease); - } }