burningtuna/Comicviewer
1
0
Fork 0
Code Issues Pull requests Projects Releases 3 Packages Wiki Activity Actions
Comicviewer/src/window.rs
burnintuna f4a0c484ff Release v0.2.7
2026-07-24 02:36:05 +09:00

2459 lines
92 KiB
Rust
Raw Blame History

use std::cell::{Cell, RefCell};
use std::fs;
use std::path::{Path, PathBuf};
use std::rc::Rc;
use std::time::{Duration, Instant};
use anyhow::{Context, Result, bail};
use chrono::{DateTime, Local};
use gtk::gio;
use gtk::gio::prelude::*;
use gtk::glib;
use gtk::prelude::*;
use crate::browser::{
BrowserEntry, EntryKind, SortDirection, SortField, classify_file, sort_entries,
};
use crate::config::{AppConfig, FavoriteEntry, LocationKind, LocationProfile, ViewerMode};
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, ViewModeControl,
ViewerWindow, install_file_drop_target, set_viewer_header, set_viewer_loading,
};
use crate::zip_cache::ZipCache;
const MOUSE_BACK_BUTTON: u32 = 8;
pub struct ComicWindow {
controller: Rc<BrowserController>,
}
impl ComicWindow {
pub fn new(
application: &gtk::Application,
config: AppConfig,
config_path: PathBuf,
database: Database,
zip_cache: Rc<ZipCache>,
) -> Result<Self> {
let initial_profile = home_profile();
let root_uri: String = root_file(&initial_profile)?.uri().into();
let window = gtk::ApplicationWindow::builder()
.application(application)
.title("Comicviewer")
.default_width(1100)
.default_height(720)
.build();
let header = gtk::HeaderBar::new();
header.set_title_widget(Some(&gtk::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);
root.set_margin_top(12);
root.set_margin_bottom(12);
root.set_margin_start(12);
root.set_margin_end(12);
let locations = gtk::Box::new(gtk::Orientation::Horizontal, 6);
let location_dropdown = gtk::DropDown::from_strings(&["내 홈"]);
location_dropdown.set_hexpand(true);
let add_location_button = gtk::Button::with_label("위치 추가");
let edit_location_button = gtk::Button::with_label("수정");
edit_location_button.set_sensitive(false);
let delete_location_button = gtk::Button::with_label("삭제");
delete_location_button.set_sensitive(false);
locations.append(&gtk::Label::new(Some("위치")));
locations.append(&location_dropdown);
locations.append(&add_location_button);
locations.append(&edit_location_button);
locations.append(&delete_location_button);
let navigation = gtk::Box::new(gtk::Orientation::Horizontal, 6);
let up_button = gtk::Button::builder()
.icon_name("go-up-symbolic")
.tooltip_text("상위 폴더")
.build();
let path_entry = gtk::Entry::builder().hexpand(true).build();
let open_button = gtk::Button::with_label("이동");
let refresh_button = gtk::Button::builder()
.icon_name("view-refresh-symbolic")
.tooltip_text("새로고침")
.build();
navigation.append(&up_button);
navigation.append(&path_entry);
navigation.append(&open_button);
navigation.append(&refresh_button);
let controls = gtk::Box::new(gtk::Orientation::Horizontal, 6);
let search_entry = gtk::SearchEntry::builder()
.placeholder_text("현재 위치 아래 폴더와 ZIP 검색")
.hexpand(true)
.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("더 많은 페이지를 미리 디코딩하여 메모리에 유지")
.build();
controls.append(&search_entry);
controls.append(&sort_dropdown);
controls.append(&direction_button);
controls.append(&case_insensitive_check);
controls.append(&gtk::Label::new(Some("빠른 이미지 로딩")));
controls.append(&fast_loading_switch);
let list_box = gtk::ListBox::new();
list_box.set_selection_mode(gtk::SelectionMode::Single);
list_box.set_activate_on_single_click(false);
let scrolled = gtk::ScrolledWindow::builder()
.vexpand(true)
.child(&list_box)
.build();
let status_label = gtk::Label::builder().xalign(0.0).build();
root.append(&locations);
root.append(&navigation);
root.append(&controls);
root.append(&scrolled);
root.append(&status_label);
window.set_child(Some(&root));
let controller = Rc::new(BrowserController {
window,
about_button,
clear_cache_button,
location_dropdown,
edit_location_button,
delete_location_button,
path_entry,
search_entry,
sort_dropdown,
direction_button,
list_box,
status_label,
state: RefCell::new(BrowserState {
profile_index: 0,
favorite_profile: None,
browsing_favorites: false,
root_uri: root_uri.clone(),
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,
typeahead_query: String::new(),
typeahead_last_input: None,
}),
config: RefCell::new(config),
config_path,
database: Rc::new(database),
zip_cache,
listing_task: RefCell::new(None),
search_task: RefCell::new(None),
search_generation: Cell::new(0),
});
controller.rebuild_profiles();
controller.connect_signals(
open_button,
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 })
}
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<LocationProfile>,
browsing_favorites: bool,
root_uri: String,
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,
typeahead_query: String,
typeahead_last_input: Option<Instant>,
}
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,
path_entry: gtk::Entry,
search_entry: gtk::SearchEntry,
sort_dropdown: gtk::DropDown,
direction_button: gtk::ToggleButton,
list_box: gtk::ListBox,
status_label: gtk::Label,
state: RefCell<BrowserState>,
config: RefCell<AppConfig>,
config_path: PathBuf,
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 {
fn connect_signals(
self: &Rc<Self>,
open_button: gtk::Button,
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);
open_button.connect_clicked(move |_| controller.open_entered_path());
let controller = Rc::clone(self);
self.path_entry
.connect_activate(move |_| controller.open_entered_path());
let controller = Rc::clone(self);
refresh_button.connect_clicked(move |_| controller.refresh());
let controller = Rc::clone(self);
up_button.connect_clicked(move |_| controller.go_up());
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));
}
});
let controller = Rc::clone(self);
self.delete_location_button.connect_clicked(move |_| {
if let Some(index) = controller.selected_config_index() {
controller.show_delete_location_dialog(index);
}
});
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::<gtk::ListItem>() 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;
};
if is_favorites_selection(item.position(), controller.profiles().len()) {
controller.show_favorites();
}
});
label.add_controller(click);
});
location_factory.connect_bind(|_, item| {
let Some(item) = item.downcast_ref::<gtk::ListItem>() else {
return;
};
let Some(label) = item.child().and_downcast::<gtk::Label>() else {
return;
};
let Some(value) = item.item().and_downcast::<gtk::StringObject>() 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.search_changed());
let controller = Rc::clone(self);
self.sort_dropdown
.connect_selected_notify(move |_| controller.change_sort_field());
let controller = Rc::clone(self);
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 controller = Rc::clone(self);
self.list_box
.connect_row_activated(move |_, row| controller.activate_row(row.index()));
let context_click = gtk::GestureClick::builder().button(3).build();
let controller = Rc::clone(self);
context_click.connect_pressed(move |_, _, x, y| {
controller.show_context_menu(x, y);
});
self.list_box.add_controller(context_click);
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_box.add_controller(key_controller);
let mouse_back = gtk::GestureClick::builder()
.button(MOUSE_BACK_BUTTON)
.propagation_phase(gtk::PropagationPhase::Capture)
.build();
let controller = Rc::clone(self);
mouse_back.connect_pressed(move |gesture, _, _, _| {
gesture.set_state(gtk::EventSequenceState::Claimed);
controller.go_up();
});
self.window.add_controller(mouse_back);
let controller = Rc::clone(self);
fast_loading_switch.connect_active_notify(move |switch| {
controller.set_fast_image_loading(switch);
});
let controller = Rc::clone(self);
self.clear_cache_button
.connect_clicked(move |_| controller.show_clear_cache_dialog());
}
fn profiles(&self) -> Vec<LocationProfile> {
let mut profiles = vec![home_profile()];
profiles.extend(self.config.borrow().locations.clone());
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
.iter()
.map(|profile| profile.name.clone())
.collect();
names.push("즐겨찾기".into());
let names: Vec<_> = names.iter().map(String::as_str).collect();
self.location_dropdown
.set_model(Some(&gtk::StringList::new(&names)));
}
fn select_profile(self: &Rc<Self>) {
let profile_index = self.location_dropdown.selected() as usize;
let profiles = self.profiles();
if is_favorites_selection(self.location_dropdown.selected(), profiles.len()) {
self.show_favorites();
return;
}
let editable = profile_index > 0 && profile_index < profiles.len();
self.edit_location_button.set_sensitive(editable);
self.delete_location_button.set_sensitive(editable);
let Some(profile) = profiles.get(profile_index) else {
return;
};
match root_file(profile) {
Ok(root) => {
let root_uri: String = root.uri().into();
let mut state = self.state.borrow_mut();
state.profile_index = profile_index;
state.favorite_profile = None;
state.browsing_favorites = false;
state.root_uri = root_uri.clone();
state.current_uri = root_uri;
drop(state);
self.path_entry.set_editable(true);
self.search_entry.set_text("");
self.refresh();
}
Err(error) => self.status_label.set_text(&format!("{error:#}")),
}
}
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("즐겨찾기");
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.browsing_favorites = true;
state.favorite_profile = None;
state.entries = entries;
drop(state);
self.search_entry.set_text("");
self.render();
}
fn open_favorite(self: &Rc<Self>, 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.browsing_favorites = false;
state.root_uri = root.uri().into();
state.current_uri = favorite.uri;
drop(state);
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<Self>) {
let browsing_favorites = self.state.borrow().browsing_favorites;
if browsing_favorites {
return;
}
let profile = self.current_profile();
let entered = self.path_entry.text();
let file = file_from_user_input(profile.kind, entered.as_str());
let root = gio::File::for_uri(&self.state.borrow().root_uri);
if !is_within_root(&file, &root) {
self.status_label
.set_text("저장된 위치의 루트 아래 경로만 열 수 있습니다.");
return;
}
self.state.borrow_mut().current_uri = file.uri().into();
self.refresh();
}
fn go_up(self: &Rc<Self>) {
let browsing_favorites = self.state.borrow().browsing_favorites;
if browsing_favorites {
return;
}
let state = self.state.borrow();
let current = gio::File::for_uri(&state.current_uri);
let root = gio::File::for_uri(&state.root_uri);
drop(state);
if let Some(parent) = parent_within_root(&current, &root) {
self.state.borrow_mut().current_uri = parent.uri().into();
self.refresh();
}
}
fn refresh(self: &Rc<Self>) {
let browsing_favorites = self.state.borrow().browsing_favorites;
if browsing_favorites {
self.show_favorites();
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
.favorite_profile
.clone()
.unwrap_or_else(|| self.profiles()[state.profile_index].clone()),
state.current_uri.clone(),
state.generation,
)
};
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 {
let result = enumerate_directory(&profile, &uri, &operation, move |count| {
let Some(controller) = progress_controller.upgrade() else {
return;
};
if controller.state.borrow().generation == generation {
controller.status_label.set_text(&format!(
"폴더를 불러오는 중... ({count}개의 파일/폴더를 읽음)"
));
}
})
.await;
let Some(controller) = controller.upgrade() else {
return;
};
let state = controller.state.borrow();
let stale = state.generation != generation || state.browsing_favorites;
drop(state);
if stale {
return;
}
match result {
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:#}")),
}
});
self.listing_task.replace(Some(task));
}
fn cancel_listing(&self) {
if let Some(task) = self.listing_task.borrow_mut().take() {
task.abort();
}
}
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);
}
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
.iter()
.filter(|entry| query.is_empty() || recursive_search_match(entry, query.as_str()))
.cloned()
.collect();
sort_entries(
&mut visible_entries,
state.sort_field,
state.sort_direction,
case_insensitive,
);
for entry in &visible_entries {
self.list_box.append(&entry_row(entry));
}
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);
}
fn typeahead(
&self,
key: gtk::gdk::Key,
modifiers: gtk::gdk::ModifierType,
) -> glib::Propagation {
let blocked = gtk::gdk::ModifierType::CONTROL_MASK
| gtk::gdk::ModifierType::ALT_MASK
| gtk::gdk::ModifierType::SUPER_MASK;
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 {
return glib::Propagation::Proceed;
};
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
.typeahead_last_input
.is_none_or(|last| now.duration_since(last) > Duration::from_millis(1200))
{
state.typeahead_query.clear();
}
let input = character.to_lowercase().collect::<String>();
let repeated_single =
state.typeahead_query.chars().count() == 1 && state.typeahead_query == input;
if !repeated_single {
state.typeahead_query.push_str(&input);
}
state.typeahead_last_input = Some(now);
let query = state.typeahead_query.clone();
let start = if repeated_single {
selected.map_or(0, |index| index + 1)
} else {
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());
drop(state);
if let Some(index) = found
&& let Some(row) = self.list_box.row_at_index(index as i32)
{
self.list_box.select_row(Some(&row));
let _ = row.grab_focus();
self.status_label.set_text(&format!(
"'{query}'로 이동: {}",
found_name.unwrap_or_default()
));
} else {
self.status_label
.set_text(&format!("'{query}'로 시작하는 항목이 없습니다."));
}
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,
2 => SortField::Created,
_ => SortField::Name,
};
self.render();
}
fn change_sort_direction(&self) {
let direction = if self.direction_button.is_active() {
self.direction_button.set_label("내림차순");
SortDirection::Descending
} else {
self.direction_button.set_label("오름차순");
SortDirection::Ascending
};
self.state.borrow_mut().sort_direction = direction;
self.render();
}
fn activate_row(self: &Rc<Self>, index: i32) {
let Some(entry) = self
.state
.borrow()
.visible_entries
.get(index as usize)
.cloned()
else {
return;
};
let browsing_favorites = self.state.borrow().browsing_favorites;
if browsing_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;
}
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 => {
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 = {
let state = self.state.borrow();
sorted_navigable_entries(
&state.entries,
current_kind,
state.sort_field,
state.sort_direction,
case_insensitive,
)
};
let siblings = Rc::new(siblings);
if siblings.iter().any(|item| item.uri == entry.uri) {
self.open_viewable(entry, siblings, self.current_profile(), None);
}
}
EntryKind::OtherFile => {}
}
}
fn open_viewable(
self: &Rc<Self>,
entry: BrowserEntry,
siblings: Rc<Vec<BrowserEntry>>,
profile: LocationProfile,
reuse_window: Option<gtk::ApplicationWindow>,
) {
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<Self>,
entry: &BrowserEntry,
siblings: Rc<Vec<BrowserEntry>>,
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<Vec<BrowserEntry>>,
fixed: bool,
) -> Rc<Vec<BrowserEntry>> {
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 browsing_favorites = state.browsing_favorites;
drop(state);
if !browsing_favorites && entries.iter().any(|entry| entry.uri == current_uri) {
Rc::new(entries)
} else {
Rc::clone(fallback)
}
}
fn open_archive(
self: &Rc<Self>,
entry: BrowserEntry,
siblings: Rc<Vec<BrowserEntry>>,
profile: LocationProfile,
reuse_window: Option<gtk::ApplicationWindow>,
) {
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 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.status_label.set_text("다운로드 완료");
result_label.set_text("ZIP 파일을 여는 중...");
let Some(application) = controller.window.application() else {
return;
};
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,
},
);
}
Err(error) => {
let message = format!("{error:#}");
controller.status_label.set_text(&message);
result_label.set_text(&message);
}
}
},
);
}
fn open_media(
self: &Rc<Self>,
entry: BrowserEntry,
siblings: Rc<Vec<BrowserEntry>>,
profile: LocationProfile,
reuse_window: Option<gtk::ApplicationWindow>,
) {
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.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,
},
);
}
Err(error) => {
let message = format!("{error:#}");
controller.status_label.set_text(&message);
result_label.set_text(&message);
}
}
},
);
}
fn show_context_menu(self: &Rc<Self>, x: f64, y: f64) {
let Some(widget) = self.list_box.pick(x, y, gtk::PickFlags::DEFAULT) else {
return;
};
let Some(row) = widget
.clone()
.downcast::<gtk::ListBoxRow>()
.ok()
.or_else(|| {
widget
.ancestor(gtk::ListBoxRow::static_type())
.and_then(|widget| widget.downcast::<gtk::ListBoxRow>().ok())
})
else {
return;
};
let Some(entry) = self
.state
.borrow()
.visible_entries
.get(row.index() 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_box.select_row(Some(&row));
let popover = gtk::Popover::new();
popover.set_parent(&row);
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 {
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,
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<Self>, 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<Self>) -> 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<Self>, files: Vec<gio::File>, 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();
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("열 항목을 확인하는 중...");
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<BrowserEntry>,
) {
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.browsing_favorites = false;
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.path_entry.set_text(&display_uri(&uri));
self.search_entry.set_text("");
self.render();
self.window.present();
}
fn view_mode_control(self: &Rc<Self>) -> 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 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;
let browsing_favorites = self.state.borrow().browsing_favorites;
if browsing_favorites {
self.show_favorites();
}
self.status_label.set_text(if active {
"즐겨찾기에 추가했습니다."
} else {
"즐겨찾기에서 제거했습니다."
});
active
}
fn choose_download_destination(
self: &Rc<Self>,
entry: BrowserEntry,
parent: gtk::Window,
status_label: gtk::Label,
) {
let dialog = gtk::FileDialog::builder()
.title("다운로드 위치 선택")
.initial_name(&entry.name)
.build();
let controller = Rc::downgrade(self);
glib::MainContext::default().spawn_local(async move {
let result = dialog.save_future(Some(&parent)).await;
let Some(controller) = controller.upgrade() else {
return;
};
match result {
Ok(destination) if destination.is_native() => {
controller.download_file(entry, destination, status_label);
}
Ok(_) => status_label.set_text("로컬 파일 시스템 위치를 선택해 주세요."),
Err(error) if error.matches(gio::IOErrorEnum::Cancelled) => {}
Err(error) => {
status_label.set_text(&format!("저장 위치를 선택할 수 없습니다: {error}"));
}
}
});
}
fn download_file(&self, entry: BrowserEntry, destination: gio::File, status_label: gtk::Label) {
let Some(final_path) = destination.path() else {
status_label.set_text("로컬 파일 시스템 위치를 선택해 주세요.");
return;
};
let part_path = download_part_path(&final_path);
let source = gio::File::for_uri(&entry.uri);
let part_file = gio::File::for_path(&part_path);
let progress_label = status_label.clone();
let result_label = status_label;
let expected_size = entry.size;
source.copy_async(
&part_file,
gio::FileCopyFlags::OVERWRITE,
glib::Priority::DEFAULT,
gio::Cancellable::NONE,
Some(Box::new(move |current, total| {
let percent = if total > 0 { current * 100 / total } else { 0 };
progress_label.set_text(&format!("{} 다운로드 중... {percent}%", entry.name));
})),
move |result| {
let completed = result.map_err(anyhow::Error::from).and_then(|()| {
let actual_size = fs::metadata(&part_path)?.len();
if expected_size.is_some_and(|expected| expected != actual_size) {
anyhow::bail!("다운로드 크기가 원본과 다릅니다.");
}
fs::rename(&part_path, &final_path)?;
Ok(())
});
if let Err(error) = completed {
let _ = fs::remove_file(&part_path);
result_label.set_text(&format!("다운로드 실패: {error:#}"));
} else {
result_label.set_text(&format!("다운로드 완료: {}", final_path.display()));
}
},
);
}
fn set_case_insensitive_sort(&self, check: &gtk::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: &gtk::Switch) {
let active = switch.is_active();
let previous = self.config.borrow().fast_image_loading;
if active == previous {
return;
}
let mut updated = self.config.borrow().clone();
updated.fast_image_loading = active;
match updated.save(&self.config_path) {
Ok(()) => {
*self.config.borrow_mut() = updated;
self.status_label.set_text(if active {
"빠른 이미지 로딩을 켰습니다."
} else {
"빠른 이미지 로딩을 껐습니다."
});
}
Err(error) => {
self.status_label
.set_text(&format!("설정을 저장할 수 없습니다: {error:#}"));
switch.set_active(previous);
}
}
}
fn selected_config_index(&self) -> Option<usize> {
let index = (self.location_dropdown.selected() as usize).checked_sub(1)?;
(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",
));
libraries.set_xalign(0.0);
libraries.set_wrap(true);
let close_button = gtk::Button::with_label("닫기");
close_button.set_halign(gtk::Align::End);
let dialog_to_close = dialog.clone();
close_button.connect_clicked(move |_| dialog_to_close.close());
content.append(&name);
content.append(&contact);
content.append(&libraries);
content.append(&close_button);
dialog.set_child(Some(&content));
dialog.present();
}
fn show_clear_cache_dialog(self: &Rc<Self>) {
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<Self>, edit_index: Option<usize>) {
let existing =
edit_index.and_then(|index| self.config.borrow().locations.get(index).cloned());
let dialog = gtk::Window::builder()
.title(if existing.is_some() {
"위치 수정"
} else {
"위치 추가"
})
.transient_for(&self.window)
.modal(true)
.default_width(520)
.build();
let content = gtk::Box::new(gtk::Orientation::Vertical, 12);
let grid = gtk::Grid::builder()
.row_spacing(8)
.column_spacing(10)
.margin_top(12)
.margin_bottom(12)
.margin_start(12)
.margin_end(12)
.build();
let kind = gtk::DropDown::from_strings(&["로컬", "SMB", "FTP", "SFTP"]);
let name = gtk::Entry::new();
let address = gtk::Entry::builder()
.placeholder_text("smb://server/share 또는 /home/user/comics")
.build();
let username = gtk::Entry::new();
let password = gtk::Entry::builder().visibility(false).build();
let domain = gtk::Entry::new();
if let Some(profile) = &existing {
kind.set_selected(location_kind_index(profile.kind));
name.set_text(&profile.name);
address.set_text(&profile.address);
username.set_text(&profile.username);
password.set_text(&profile.password);
domain.set_text(&profile.domain);
}
for (row, label, widget) in [
(0, "종류", kind.clone().upcast::<gtk::Widget>()),
(1, "이름", name.clone().upcast()),
(2, "주소", address.clone().upcast()),
(3, "사용자", username.clone().upcast()),
(4, "비밀번호", password.clone().upcast()),
(5, "SMB 도메인", domain.clone().upcast()),
] {
grid.attach(&gtk::Label::new(Some(label)), 0, row, 1, 1);
grid.attach(&widget, 1, row, 1, 1);
}
let actions = gtk::Box::new(gtk::Orientation::Horizontal, 6);
actions.set_halign(gtk::Align::End);
actions.set_margin_bottom(12);
actions.set_margin_end(12);
let cancel_button = gtk::Button::with_label("취소");
let save_button = gtk::Button::with_label("저장");
actions.append(&cancel_button);
actions.append(&save_button);
content.append(&grid);
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();
save_button.connect_clicked(move |_| {
let profile = LocationProfile {
name: name.text().into(),
kind: match kind.selected() {
1 => LocationKind::Smb,
2 => LocationKind::Ftp,
3 => LocationKind::Sftp,
_ => LocationKind::Local,
},
address: address.text().into(),
username: username.text().into(),
password: password.text().into(),
domain: domain.text().into(),
};
if let Err(error) = validate_profile(&profile) {
controller.status_label.set_text(&format!("{error:#}"));
return;
}
let mut updated = controller.config.borrow().clone();
let selected_profile = if let Some(index) = edit_index {
let Some(existing) = updated.locations.get_mut(index) else {
controller
.status_label
.set_text("수정할 위치를 찾을 수 없습니다.");
return;
};
*existing = profile;
index + 1
} else {
updated.locations.push(profile);
updated.locations.len()
};
if let Err(error) = updated.save(&controller.config_path) {
controller.status_label.set_text(&format!("{error:#}"));
return;
}
*controller.config.borrow_mut() = updated;
controller.rebuild_profiles();
controller
.location_dropdown
.set_selected(selected_profile as u32);
dialog_to_close.close();
});
dialog.present();
}
fn show_delete_location_dialog(self: &Rc<Self>, index: usize) {
let Some(profile) = self.config.borrow().locations.get(index).cloned() else {
return;
};
let dialog = gtk::Window::builder()
.title("위치 삭제")
.transient_for(&self.window)
.modal(true)
.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(&format!(
"저장된 위치 '{}'을(를) 삭제하시겠습니까?\n서버의 파일은 삭제되지 않습니다.",
profile.name
)));
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 delete_button = gtk::Button::with_label("삭제");
delete_button.add_css_class("destructive-action");
actions.append(&cancel_button);
actions.append(&delete_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();
delete_button.connect_clicked(move |_| {
let mut updated = controller.config.borrow().clone();
if index >= updated.locations.len() {
controller
.status_label
.set_text("삭제할 위치를 찾을 수 없습니다.");
dialog_to_close.close();
return;
}
updated.locations.remove(index);
if let Err(error) = updated.save(&controller.config_path) {
controller.status_label.set_text(&format!("{error:#}"));
return;
}
*controller.config.borrow_mut() = updated;
controller.rebuild_profiles();
controller.location_dropdown.set_selected(0);
controller
.status_label
.set_text("저장된 위치를 삭제했습니다.");
dialog_to_close.close();
});
dialog.present();
}
}
fn location_kind_index(kind: LocationKind) -> u32 {
match kind {
LocationKind::Local => 0,
LocationKind::Smb => 1,
LocationKind::Ftp => 2,
LocationKind::Sftp => 3,
}
}
fn home_profile() -> LocationProfile {
LocationProfile {
name: "내 홈".into(),
kind: LocationKind::Local,
address: std::env::var("HOME").unwrap_or_else(|_| "/".into()),
username: String::new(),
password: String::new(),
domain: String::new(),
}
}
fn local_profile_for_directory(directory: &gio::File) -> Result<LocationProfile> {
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: &gtk::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(
|| display_remote_uri(file.uri().as_str()),
|path| path.to_string_lossy().into_owned(),
)
}
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);
let icon = 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",
};
content.append(&gtk::Image::from_icon_name(icon));
content.append(
&gtk::Label::builder()
.label(entry.display_name())
.hexpand(true)
.xalign(0.0)
.ellipsize(gtk::pango::EllipsizeMode::Middle)
.build(),
);
for time in [entry.modified, entry.created] {
let label = gtk::Label::new(Some(&format_time(time)));
label.set_width_chars(17);
label.set_xalign(1.0);
content.append(&label);
}
row.set_child(Some(&content));
row
}
fn format_time(time: Option<std::time::SystemTime>) -> String {
time.map(|time| {
let datetime: DateTime<Local> = time.into();
datetime.format("%Y-%m-%d %H:%M").to_string()
})
.unwrap_or_else(|| "-".into())
}
fn find_prefix_index(entries: &[BrowserEntry], query: &str, start: usize) -> Option<usize> {
if entries.is_empty() {
return None;
}
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 is_favorites_selection(selected: u32, profile_count: usize) -> bool {
selected != gtk::INVALID_LIST_POSITION && selected as usize == profile_count
}
fn sorted_navigable_entries(
entries: &[BrowserEntry],
current_kind: EntryKind,
sort_field: SortField,
sort_direction: SortDirection,
case_insensitive: bool,
) -> Vec<BrowserEntry> {
let mut siblings = entries
.iter()
.filter(|entry| navigable_sibling(current_kind, entry.kind))
.cloned()
.collect::<Vec<_>>();
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<BrowserEntry>, 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 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 {
classify_file(Path::new(&favorite.name))
},
size: None,
modified: None,
created: None,
etag: None,
}
}
fn show_viewer_loading(
window: &gtk::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(&gtk::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
}
}
#[cfg(test)]
mod tests {
use super::*;
fn entry(name: &str) -> BrowserEntry {
BrowserEntry {
uri: format!("file:///{name}"),
name: name.into(),
list_name: None,
kind: EntryKind::Directory,
size: None,
modified: None,
created: None,
etag: None,
}
}
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")];
assert_eq!(find_prefix_index(&entries, "br", 0), Some(2));
assert_eq!(find_prefix_index(&entries, "AL", 0), Some(0));
}
#[test]
fn repeated_typeahead_wraps_to_next_match() {
let entries = [entry("Alpha"), entry("beta"), entry("Bravo")];
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 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);
}
#[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 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!(is_favorites_selection(3, 3));
assert!(!is_favorites_selection(2, 3));
assert!(!is_favorites_selection(gtk::INVALID_LIST_POSITION, 3));
}
#[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());
}
}
Reference in a new issue View git blame Copy permalink