burningtuna/Comicviewer
1
0
Fork 0
Code Issues Pull requests Projects Releases 3 Packages Wiki Activity Actions

Release v0.2.8

Browse source
This commit is contained in:
burnintuna 2026-07-24 21:55:41 +09:00
parent f4a0c484ff
commit 6c54ec8139
9 changed files with 151 additions and 400 deletions
Download patch file Download diff file Expand all files Collapse all files

244
src/window.rs
View file

@ -1,4 +1,4 @@
use std::cell::{Cell, RefCell};
use std::cell::RefCell;
use std::fs;
use std::path::{Path, PathBuf};
use std::rc::Rc;
@ -97,7 +97,7 @@ impl ComicWindow {
let controls = gtk::Box::new(gtk::Orientation::Horizontal, 6);
let search_entry = gtk::SearchEntry::builder()
.placeholder_text("현재 위치 아래 폴더와 ZIP 검색")
.placeholder_text("현재 폴더에서 검색")
.hexpand(true)
.build();
let sort_dropdown = gtk::DropDown::from_strings(&["이름", "수정 시간", "생성 시간"]);
@ -152,10 +152,6 @@ impl ComicWindow {
current_uri: root_uri,
entries: Vec::new(),
visible_entries: Vec::new(),
recursive_entries: Vec::new(),
recursive_root_uri: None,
recursive_ready: false,
recursive_scanning: false,
sort_field: SortField::Name,
sort_direction: SortDirection::Ascending,
generation: 0,
@ -167,8 +163,6 @@ impl ComicWindow {
database: Rc::new(database),
zip_cache,
listing_task: RefCell::new(None),
search_task: RefCell::new(None),
search_generation: Cell::new(0),
});
controller.rebuild_profiles();
@ -204,10 +198,6 @@ struct BrowserState {
current_uri: String,
entries: Vec<BrowserEntry>,
visible_entries: Vec<BrowserEntry>,
recursive_entries: Vec<BrowserEntry>,
recursive_root_uri: Option<String>,
recursive_ready: bool,
recursive_scanning: bool,
sort_field: SortField,
sort_direction: SortDirection,
generation: u64,
@ -234,8 +224,6 @@ struct BrowserController {
database: Rc<Database>,
zip_cache: Rc<ZipCache>,
listing_task: RefCell<Option<glib::JoinHandle<()>>>,
search_task: RefCell<Option<glib::JoinHandle<()>>>,
search_generation: Cell<u64>,
}
impl BrowserController {
@ -317,7 +305,7 @@ impl BrowserController {
.set_list_factory(Some(&location_factory));
let controller = Rc::clone(self);
self.search_entry
.connect_search_changed(move |_| controller.search_changed());
.connect_search_changed(move |_| controller.render());
let controller = Rc::clone(self);
self.sort_dropdown
.connect_selected_notify(move |_| controller.change_sort_field());
@ -432,7 +420,6 @@ impl BrowserController {
fn show_favorites(&self) {
self.cancel_listing();
self.cancel_recursive_search();
self.edit_location_button.set_sensitive(false);
self.delete_location_button.set_sensitive(false);
self.path_entry.set_text("즐겨찾기");
@ -594,12 +581,13 @@ impl BrowserController {
return;
}
self.cancel_listing();
self.cancel_recursive_search();
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
@ -609,6 +597,9 @@ impl BrowserController {
state.generation,
)
};
while let Some(child) = self.list_box.first_child() {
self.list_box.remove(&child);
}
self.path_entry.set_text(&display_uri(&uri));
self.status_label
.set_text("폴더를 불러오는 중... (0개의 파일/폴더를 읽음)");
@ -640,9 +631,6 @@ impl BrowserController {
Ok(entries) => {
controller.state.borrow_mut().entries = entries;
controller.render();
if !controller.search_entry.text().is_empty() {
controller.start_recursive_search();
}
}
Err(error) => controller.status_label.set_text(&format!("{error:#}")),
}
@ -656,142 +644,6 @@ impl BrowserController {
}
}
fn cancel_recursive_search(&self) {
if let Some(task) = self.search_task.borrow_mut().take() {
task.abort();
}
self.search_generation
.set(self.search_generation.get().wrapping_add(1));
let mut state = self.state.borrow_mut();
state.recursive_entries.clear();
state.recursive_root_uri = None;
state.recursive_ready = false;
state.recursive_scanning = false;
}
fn search_changed(self: &Rc<Self>) {
if self.search_entry.text().is_empty() {
self.cancel_recursive_search();
self.render();
return;
}
self.render();
if !self.state.borrow().browsing_favorites {
self.start_recursive_search();
}
}
fn start_recursive_search(self: &Rc<Self>) {
let (profile, root_uri) = {
let mut state = self.state.borrow_mut();
if state.browsing_favorites
|| (state.recursive_root_uri.as_deref() == Some(&state.current_uri)
&& (state.recursive_ready || state.recursive_scanning))
{
return;
}
let root_uri = state.current_uri.clone();
state.recursive_root_uri = Some(root_uri.clone());
state.recursive_entries.clear();
state.recursive_ready = false;
state.recursive_scanning = true;
(
state
.favorite_profile
.clone()
.unwrap_or_else(|| self.profiles()[state.profile_index].clone()),
root_uri,
)
};
if let Some(task) = self.search_task.borrow_mut().take() {
task.abort();
}
let generation = self.search_generation.get().wrapping_add(1);
self.search_generation.set(generation);
let root = gio::File::for_uri(&root_uri);
let location_id = root_file(&profile)
.map(|root| root.uri().to_string())
.unwrap_or_else(|_| profile.address.clone());
if let Ok(cached_entries) = self.database.load_cached_tree(&location_id, &root_uri)
&& !cached_entries.is_empty()
{
let mut state = self.state.borrow_mut();
state.recursive_entries = cached_entries;
state.recursive_ready = true;
drop(state);
self.render();
}
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, &root, Some(&operation), move |progress| {
let Some(controller) = progress_controller.upgrade() else {
return;
};
if controller.search_generation.get() == generation
&& !controller.search_entry.text().is_empty()
{
controller.status_label.set_text(&format!(
"하위 폴더 검색 색인 생성 중... (폴더 {}개, 항목 {}개)",
progress.directories, progress.scanned
));
}
})
.await;
let Some(controller) = controller.upgrade() else {
return;
};
if controller.search_generation.get() != generation
|| controller.state.borrow().current_uri != root_uri
{
return;
}
match result {
Ok((entries, progress)) => {
let cache_error = (progress.skipped == 0)
.then(|| {
controller.database.replace_cached_tree(
&location_id,
&root_uri,
&entries,
)
})
.transpose()
.err();
let mut state = controller.state.borrow_mut();
state.recursive_entries = entries;
state.recursive_ready = true;
state.recursive_scanning = false;
drop(state);
if !controller.search_entry.text().is_empty() {
controller.render();
if progress.skipped > 0 {
controller.status_label.set_text(&format!(
"검색 결과 생성 완료 · 접근할 수 없는 폴더 {}개 건너뜀",
progress.skipped
));
} else if let Some(error) = cache_error {
controller
.status_label
.set_text(&format!("검색 색인을 저장할 수 없습니다: {error:#}"));
}
}
}
Err(error) => {
controller.state.borrow_mut().recursive_scanning = false;
if !controller.search_entry.text().is_empty() {
controller
.status_label
.set_text(&format!("하위 폴더 검색을 완료할 수 없습니다: {error:#}"));
}
}
}
});
self.search_task.replace(Some(task));
}
fn render(&self) {
while let Some(child) = self.list_box.first_child() {
self.list_box.remove(&child);
@ -799,17 +651,10 @@ impl BrowserController {
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 recursive_ready = !query.is_empty()
&& state.recursive_ready
&& state.recursive_root_uri.as_deref() == Some(&state.current_uri);
let source = if recursive_ready {
&state.recursive_entries
} else {
&state.entries
};
let mut visible_entries: Vec<_> = source
let mut visible_entries: Vec<_> = state
.entries
.iter()
.filter(|entry| query.is_empty() || recursive_search_match(entry, query.as_str()))
.filter(|entry| browser_search_match(entry, query.as_str()))
.cloned()
.collect();
sort_entries(
@ -823,14 +668,7 @@ impl BrowserController {
}
let count = visible_entries.len();
state.visible_entries = visible_entries;
let status = if query.is_empty() {
format!("{count}개 항목")
} else if state.recursive_scanning {
format!("현재 폴더 결과 {count}개 · 하위 폴더 색인 생성 중...")
} else {
format!("하위 폴더 검색 결과 {count}개")
};
self.status_label.set_text(&status);
self.status_label.set_text(&format!("{count}개 항목"));
}
fn typeahead(
@ -964,23 +802,6 @@ impl BrowserController {
self.refresh();
}
EntryKind::ZipArchive | EntryKind::Image | EntryKind::Video => {
if !self.search_entry.text().is_empty() && entry.list_name.is_some() {
let siblings = self
.state
.borrow()
.visible_entries
.iter()
.filter(|candidate| candidate.kind.is_viewable())
.cloned()
.collect::<Vec<_>>();
self.open_viewable(
entry.clone(),
Rc::new(siblings),
self.current_profile(),
None,
);
return;
}
let current_kind = entry.kind;
let case_insensitive = self.config.borrow().case_insensitive_sort;
let siblings = {
@ -1363,7 +1184,6 @@ impl BrowserController {
}
fn open_folder_recursive(self: &Rc<Self>, entry: BrowserEntry) {
self.cancel_recursive_search();
let profile = self.profile_for_entry(&entry);
let Ok(profile_root) = root_file(&profile) else {
self.status_label
@ -1491,7 +1311,6 @@ impl BrowserController {
}
let file = file.clone();
self.cancel_listing();
self.cancel_recursive_search();
let generation = {
let mut state = self.state.borrow_mut();
state.generation = state.generation.wrapping_add(1);
@ -2155,6 +1974,10 @@ 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 is_favorites_selection(selected: u32, profile_count: usize) -> bool {
selected != gtk::INVALID_LIST_POSITION && selected as usize == profile_count
}
@ -2193,14 +2016,6 @@ fn sorted_navigable_selection(
Some((entries, selected))
}
fn recursive_search_match(entry: &BrowserEntry, lowercase_query: &str) -> bool {
matches!(entry.kind, EntryKind::Directory | EntryKind::ZipArchive)
&& entry
.display_name()
.to_lowercase()
.contains(lowercase_query)
}
fn favorite_browser_entry(favorite: &FavoriteEntry) -> BrowserEntry {
BrowserEntry {
uri: favorite.uri.clone(),
@ -2380,19 +2195,6 @@ mod tests {
assert_eq!(siblings[selected].name, "page10.jpg");
}
#[test]
fn recursive_search_only_matches_folders_and_zip_names() {
let mut folder = entry("Comics");
folder.list_name = Some("Archive/Comics".into());
let mut zip = media_entry("book.zip");
zip.kind = EntryKind::ZipArchive;
let image = media_entry("book.jpg");
assert!(recursive_search_match(&folder, "comics"));
assert!(recursive_search_match(&zip, "book"));
assert!(!recursive_search_match(&image, "book"));
}
#[test]
fn mouse_back_button_matches_standard_x11_button() {
assert_eq!(MOUSE_BACK_BUTTON, 8);
@ -2411,6 +2213,20 @@ mod tests {
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 favorites_are_rendered_as_browser_paths_and_files() {
let profile = home_profile();