Release v0.2.3

src/window.rs

@@ -1,4 +1,4 @@
-use std::cell::RefCell;
+use std::cell::{Cell, RefCell};
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
@@ -17,13 +17,14 @@ use crate::browser::{
 use crate::config::{AppConfig, FavoriteEntry, LocationKind, LocationProfile, ViewerMode};
 use crate::database::Database;
 use crate::source::{
-    display_remote_uri, ensure_mounted, enumerate_directory, file_from_user_input, is_within_root,
-    mount_operation, parent_within_root, root_file, validate_profile,
+    display_remote_uri, ensure_mounted, enumerate_directory, enumerate_tree_entries,
+    file_from_user_input, is_within_root, mount_operation, parent_within_root, root_file,
+    validate_profile,
 };
 use crate::viewer::{
     FavoriteControl, FileDownloadControl, FileDropControl, FileViewerControls, MediaViewerWindow,
     SiblingFile, SiblingFileActions, SiblingNavigator, SiblingTarget, ViewModeControl,
-    ViewerWindow, install_file_drop_target, set_viewer_header,
+    ViewerWindow, install_file_drop_target, set_viewer_header, set_viewer_loading,
 };
 use crate::zip_cache::ZipCache;
 
@@ -94,7 +95,7 @@ impl ComicWindow {
 
         let controls = gtk::Box::new(gtk::Orientation::Horizontal, 6);
         let search_entry = gtk::SearchEntry::builder()
-            .placeholder_text("현재 폴더에서 검색")
+            .placeholder_text("현재 위치 아래 폴더와 ZIP 검색")
             .hexpand(true)
             .build();
         let sort_dropdown = gtk::DropDown::from_strings(&["이름", "수정 시간", "생성 시간"]);
@@ -149,6 +150,10 @@ 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,
@@ -160,6 +165,8 @@ 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();
@@ -179,6 +186,12 @@ 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 {
@@ -189,6 +202,10 @@ 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,
@@ -215,6 +232,8 @@ 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 {
@@ -296,7 +315,7 @@ impl BrowserController {
             .set_list_factory(Some(&location_factory));
         let controller = Rc::clone(self);
         self.search_entry
-            .connect_search_changed(move |_| controller.render());
+            .connect_search_changed(move |_| controller.search_changed());
         let controller = Rc::clone(self);
         self.sort_dropdown
             .connect_selected_notify(move |_| controller.change_sort_field());
@@ -321,7 +340,7 @@ impl BrowserController {
         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 {
+            if key == gtk::gdk::Key::BackSpace && !controller.typeahead_is_active() {
                 controller.go_up();
                 glib::Propagation::Stop
             } else {
@@ -400,6 +419,7 @@ 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("즐겨찾기");
@@ -495,6 +515,7 @@ impl BrowserController {
                 .unwrap_or_else(|| BrowserEntry {
                     uri: favorite.uri.clone(),
                     name: favorite.name.clone(),
+                    list_name: None,
                     kind,
                     size: None,
                     modified: None,
@@ -560,6 +581,7 @@ 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);
@@ -605,6 +627,9 @@ 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:#}")),
             }
@@ -618,6 +643,142 @@ 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);
@@ -625,10 +786,17 @@ 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 mut visible_entries: Vec<_> = state
-            .entries
+        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
             .iter()
-            .filter(|entry| entry.name.to_lowercase().contains(query.as_str()))
+            .filter(|entry| query.is_empty() || recursive_search_match(entry, query.as_str()))
             .cloned()
             .collect();
         sort_entries(
@@ -642,7 +810,14 @@ impl BrowserController {
         }
         let count = visible_entries.len();
         state.visible_entries = visible_entries;
-        self.status_label.set_text(&format!("{count}개 항목"));
+        let status = if query.is_empty() {
+            format!("{count}개 항목")
+        } else if state.recursive_scanning {
+            format!("현재 폴더 결과 {count}개 · 하위 폴더 색인 생성 중...")
+        } else {
+            format!("하위 폴더 검색 결과 {count}개")
+        };
+        self.status_label.set_text(&status);
     }
 
     fn typeahead(
@@ -656,10 +831,21 @@ impl BrowserController {
         if modifiers.intersects(blocked) {
             return glib::Propagation::Proceed;
         }
-        let Some(character) = key
-            .to_unicode()
-            .filter(|character| character.is_alphanumeric())
-        else {
+        if key == gtk::gdk::Key::Escape {
+            let mut state = self.state.borrow_mut();
+            state.typeahead_query.clear();
+            state.typeahead_last_input = None;
+            return glib::Propagation::Stop;
+        }
+        if key == gtk::gdk::Key::BackSpace {
+            let mut state = self.state.borrow_mut();
+            if state.typeahead_query.pop().is_none() {
+                return glib::Propagation::Proceed;
+            }
+            state.typeahead_last_input = Some(Instant::now());
+            return glib::Propagation::Stop;
+        }
+        let Some(character) = key.to_unicode().filter(|character| !character.is_control()) else {
             return glib::Propagation::Proceed;
         };
 
@@ -686,7 +872,7 @@ impl BrowserController {
             0
         };
         let found = find_prefix_index(&state.visible_entries, &query, start);
-        let found_name = found.map(|index| state.visible_entries[index].name.clone());
+        let found_name = found.map(|index| state.visible_entries[index].display_name().to_owned());
         drop(state);
 
         if let Some(index) = found
@@ -705,6 +891,14 @@ impl BrowserController {
         glib::Propagation::Stop
     }
 
+    fn typeahead_is_active(&self) -> bool {
+        let state = self.state.borrow();
+        !state.typeahead_query.is_empty()
+            && state.typeahead_last_input.is_some_and(|last| {
+                Instant::now().duration_since(last) <= Duration::from_millis(1200)
+            })
+    }
+
     fn change_sort_field(&self) {
         self.state.borrow_mut().sort_field = match self.sort_dropdown.selected() {
             1 => SortField::Modified,
@@ -757,6 +951,23 @@ 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 = {
@@ -859,7 +1070,7 @@ impl BrowserController {
                 .iter()
                 .map(|entry| SiblingFile {
                     uri: entry.uri.clone(),
-                    name: entry.name.clone(),
+                    name: entry.display_name().to_owned(),
                     kind: entry.kind,
                 })
                 .collect()
@@ -1075,6 +1286,17 @@ impl BrowserController {
         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 {
@@ -1088,7 +1310,7 @@ impl BrowserController {
             let favorite_entry = entry.clone();
             favorite_button.connect_clicked(move |_| {
                 popover_to_close.popdown();
-                let profile = controller.current_profile();
+                let profile = controller.profile_for_entry(&favorite_entry);
                 controller.toggle_favorite(&favorite_entry, &profile);
             });
         }
@@ -1118,6 +1340,96 @@ impl BrowserController {
             .any(|favorite| favorite.uri == uri)
     }
 
+    fn profile_for_entry(&self, entry: &BrowserEntry) -> LocationProfile {
+        if self.state.borrow().browsing_favorites
+            && let Some(profile) = self
+                .config
+                .borrow()
+                .favorites
+                .iter()
+                .find(|favorite| favorite.uri == entry.uri)
+                .map(|favorite| favorite.profile.clone())
+        {
+            return profile;
+        }
+        self.current_profile()
+    }
+
+    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
+                .set_text("폴더의 저장된 위치 정보를 확인할 수 없습니다.");
+            return;
+        };
+        let folder = gio::File::for_uri(&entry.uri);
+        if !is_within_root(&folder, &profile_root) {
+            self.status_label
+                .set_text("저장된 위치의 루트 아래 폴더만 열 수 있습니다.");
+            return;
+        }
+        self.cancel_listing();
+        let (generation, sort_field, sort_direction) = {
+            let mut state = self.state.borrow_mut();
+            state.generation = state.generation.wrapping_add(1);
+            (state.generation, state.sort_field, state.sort_direction)
+        };
+        let case_insensitive = self.config.borrow().case_insensitive_sort;
+        self.status_label
+            .set_text("하위 폴더에서 열 수 있는 파일을 찾는 중...");
+        let operation = mount_operation(&profile, &self.window);
+        let progress_controller = Rc::downgrade(self);
+        let controller = Rc::downgrade(self);
+        let task = glib::MainContext::default().spawn_local(async move {
+            let result =
+                enumerate_tree_entries(&profile, &folder, Some(&operation), move |progress| {
+                    let Some(controller) = progress_controller.upgrade() else {
+                        return;
+                    };
+                    if controller.state.borrow().generation == generation {
+                        controller.status_label.set_text(&format!(
+                            "하위 폴더 검색 중... (폴더 {}개, 항목 {}개, 파일 {}개)",
+                            progress.directories, progress.scanned, progress.viewable
+                        ));
+                    }
+                })
+                .await;
+            let Some(controller) = controller.upgrade() else {
+                return;
+            };
+            if controller.state.borrow().generation != generation {
+                return;
+            }
+            match result {
+                Ok((mut entries, progress)) => {
+                    entries.retain(|entry| entry.kind.is_viewable());
+                    sort_entries(&mut entries, sort_field, sort_direction, case_insensitive);
+                    let Some(initial) = entries.first().cloned() else {
+                        controller
+                            .status_label
+                            .set_text("하위 폴더에 열 수 있는 파일이 없습니다.");
+                        return;
+                    };
+                    let skipped = if progress.skipped == 0 {
+                        String::new()
+                    } else {
+                        format!(" · 접근할 수 없는 폴더 {}개 건너뜀", progress.skipped)
+                    };
+                    controller.status_label.set_text(&format!(
+                        "하위 폴더에서 {}개 파일을 찾았습니다{skipped}.",
+                        entries.len()
+                    ));
+                    controller.open_viewable(initial, Rc::new(entries), profile, None);
+                }
+                Err(error) => controller
+                    .status_label
+                    .set_text(&format!("하위 폴더를 열 수 없습니다: {error:#}")),
+            }
+        });
+        self.listing_task.replace(Some(task));
+    }
+
     fn favorite_control(
         self: &Rc<Self>,
         entry: &BrowserEntry,
@@ -1172,12 +1484,13 @@ 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);
             state.generation
         };
-        self.status_label.set_text("드롭한 항목을 확인하는 중...");
+        self.status_label.set_text("열 항목을 확인하는 중...");
         let controller = Rc::downgrade(self);
         let task = glib::MainContext::default().spawn_local(async move {
             let result: Result<_> = async {
@@ -1188,7 +1501,7 @@ impl BrowserController {
                         glib::Priority::DEFAULT,
                     )
                     .await
-                    .context("드롭한 항목을 확인할 수 없습니다")?;
+                    .context("열 항목을 확인할 수 없습니다")?;
                 let selected = match info.file_type() {
                     gio::FileType::Directory => None,
                     gio::FileType::Regular => {
@@ -1221,7 +1534,7 @@ impl BrowserController {
             let (directory, profile, entries, selected) = match result {
                 Ok(result) => result,
                 Err(error) => {
-                    let message = format!("드롭한 항목을 열 수 없습니다: {error:#}");
+                    let message = format!("항목을 열 수 없습니다: {error:#}");
                     controller.status_label.set_text(&message);
                     show_drop_error(&parent, &message);
                     return;
@@ -1236,7 +1549,7 @@ impl BrowserController {
                 .find(|entry| gio::File::for_uri(&entry.uri).equal(&selected))
                 .cloned()
             else {
-                show_drop_error(&parent, "드롭한 파일을 부모 폴더에서 찾을 수 없습니다.");
+                show_drop_error(&parent, "파일을 부모 폴더에서 찾을 수 없습니다.");
                 return;
             };
             let state = controller.state.borrow();
@@ -1248,7 +1561,7 @@ impl BrowserController {
                 controller.config.borrow().case_insensitive_sort,
             ) else {
                 drop(state);
-                show_drop_error(&parent, "드롭한 파일의 목록 위치를 확인할 수 없습니다.");
+                show_drop_error(&parent, "파일의 목록 위치를 확인할 수 없습니다.");
                 return;
             };
             drop(state);
@@ -1792,7 +2105,7 @@ fn entry_row(entry: &BrowserEntry) -> gtk::ListBoxRow {
     content.append(&gtk::Image::from_icon_name(icon));
     content.append(
         &gtk::Label::builder()
-            .label(&entry.name)
+            .label(entry.display_name())
             .hexpand(true)
             .xalign(0.0)
             .ellipsize(gtk::pango::EllipsizeMode::Middle)
@@ -1823,7 +2136,12 @@ 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].name.to_lowercase().starts_with(&query))
+        .find(|index| {
+            entries[*index]
+                .display_name()
+                .to_lowercase()
+                .starts_with(&query)
+        })
 }
 
 fn navigable_sibling(current: EntryKind, candidate: EntryKind) -> bool {
@@ -1868,10 +2186,19 @@ 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(),
         name: favorite.name.clone(),
+        list_name: None,
         kind: if favorite.is_directory {
             EntryKind::Directory
         } else {
@@ -1889,6 +2216,7 @@ fn show_viewer_loading(
     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(&gtk::Label::new(Some(file_name))));
@@ -1953,6 +2281,7 @@ mod tests {
         BrowserEntry {
             uri: format!("file:///{name}"),
             name: name.into(),
+            list_name: None,
             kind: EntryKind::Directory,
             size: None,
             modified: None,
@@ -2044,6 +2373,19 @@ 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 dropped_directory_creates_local_root_profile() {
         let directory = tempfile::tempdir().unwrap();