//! The built-in GTK launcher: a search entry over Drive and this computer, //! the results on the left and a preview of the selected one on the right. //! //! Focus never leaves the search entry. The arrow keys move a cursor through //! the results, Enter opens, Ctrl+Enter shows the file in its folder and //! Ctrl+C copies its path. A single click selects a row, a double-click opens //! it, and a row can be dragged out as a file. mod highlight; mod history; mod preview; mod row; mod thumbs; use std::cell::{Cell, RefCell}; use std::path::{Path, PathBuf}; use std::rc::Rc; use adw::prelude::*; use gtk4::{gdk, gio, glib}; use pdfs_core::config::AppDirs; use pdfs_core::control::{Request, Response, SearchFilters, SearchHit, SearchSource}; use pdfs_core::opener::{self, OpenWith}; use crate::activation::{DriveActivation, drive_activation, mounted_or_relative, present_within}; use crate::compat::{Spinner, spinner}; use crate::theme::set_proton_theme; use crate::{ FILTERS, Filter, Hit, SEARCH_DEBOUNCE, SEARCH_LIMIT, file_name, gettext, gettext_f, ngettext_f, rank_hits_by, spawn_request, }; use history::History; use preview::Preview; use thumbs::Thumbs; /// Recent files shown above the pinned ones while the query is empty. const RECENT_LIMIT: usize = 8; /// The titled groups of the result list. #[derive(Debug, Clone, Copy, PartialEq, Eq)] enum Section { Recent, Pinned, Matches, } impl Section { fn title(self) -> String { match self { // Translators: the launcher's section of recently opened files. Section::Recent => gettext("Recent"), Section::Pinned => gettext("Pinned in Proton Drive"), Section::Matches => gettext("Best matches"), } } fn icon(self) -> &'static str { match self { Section::Recent => "document-open-recent-symbolic", Section::Pinned => "view-pin-symbolic", Section::Matches => "system-search-symbolic", } } fn header(self) -> gtk4::Box { let header = gtk4::Box::new(gtk4::Orientation::Horizontal, 8); header.add_css_class("section-header"); let image = gtk4::Image::from_icon_name(self.icon()); image.add_css_class("section-icon"); header.append(&image); let label = gtk4::Label::builder() .label(self.title()) .xalign(0.0) .build(); label.add_css_class("section-title"); header.append(&label); header } } /// Everything the window needs to render and act, in one place so the many /// callbacks below capture a single `Rc` instead of a dozen clones each. pub(crate) struct Ui { socket: PathBuf, mountpoint: RefCell, /// How a chosen file is launched. Re-read on every activation, so a /// change in the app applies the next time the launcher opens. opener: RefCell, window: adw::ApplicationWindow, entry: gtk4::Entry, spinner: Spinner, stack: gtk4::Stack, scroller: gtk4::ScrolledWindow, list: gtk4::ListBox, /// The section that starts at each row index, for the header function. headers: Rc>>>, placeholder: adw::StatusPage, hint: gtk4::Label, chips: RefCell>, preview: Preview, /// The hit the preview shows, so a repeated selection does not redo it. previewed: RefCell>, thumbs: Rc, history: History, /// Raw (unfiltered) hits from the last reply: search results, or the /// pinned files while the query is empty. drive_hits: RefCell>, local_hits: RefCell>, /// The rows in list order; the cursor indexes into it. visible: RefCell>, cursor: Cell>, /// The trimmed query the currently-rendered rows belong to. Enter compares /// against it so a keystroke that lands just before a fresher render can't /// open a file from a result set the user has already typed past. rendered_query: RefCell, filter: Cell, /// Monotonic query id. A reply whose id is stale (the user typed again while /// it was in flight) is dropped instead of overwriting fresher results. query_id: Cell, /// In-flight requests for the current query id. pending: Cell, /// The ticket of the Drive open in progress. Escape clears it, and a /// reply for a ticket that is no longer current launches nothing. opening: Cell>, last_ticket: Cell, indexing: Cell, /// Set when Enter arrives before the in-flight query has rendered (typing /// then hitting Enter faster than the search debounce). The open is honoured /// against the selected row once the fresh results settle, rather than being /// dropped — so a plain "type, Enter" always opens something. open_pending: Cell, /// Prevent lifecycle-driven entry resets from also scheduling the normal /// debounced empty-query request; activation performs one explicit daemon /// bootstrap instead. suppress_entry_change: Cell, } pub(crate) fn build_window(app: &adw::Application) -> Option> { let dirs = match AppDirs::new() { Ok(d) => d, Err(e) => { tracing::error!("cannot resolve app dirs: {e}"); return None; } }; let window = adw::ApplicationWindow::builder() .application(app) .title(gettext("Search Proton Drive")) .default_width(860) .default_height(560) .resizable(false) .decorated(false) .build(); window.add_css_class("launcher-window"); let card = gtk4::Box::new(gtk4::Orientation::Vertical, 0); card.add_css_class("launcher-card"); window.set_content(Some(&card)); // --- search bar ------------------------------------------------------- let search_bar = gtk4::Box::new(gtk4::Orientation::Horizontal, 10); search_bar.add_css_class("search-bar"); let search_icon = gtk4::Image::from_icon_name("system-search-symbolic"); search_icon.add_css_class("search-icon"); search_bar.append(&search_icon); let entry = gtk4::Entry::builder() .placeholder_text(gettext("Search in Drive and on this computer")) .hexpand(true) .build(); entry.add_css_class("search-entry"); search_bar.append(&entry); let spinner = spinner(); spinner.set_visible(false); search_bar.append(&spinner); // Translators: the Escape key, shown as a hint that it closes the window. let esc = gtk4::Label::new(Some(&gettext("Esc"))); esc.add_css_class("key-hint"); search_bar.append(&esc); card.append(&search_bar); // --- filter chips ----------------------------------------------------- let chip_row = gtk4::Box::new(gtk4::Orientation::Horizontal, 8); chip_row.add_css_class("chip-row"); card.append(&chip_row); // --- results and preview ---------------------------------------------- let list = gtk4::ListBox::builder() .selection_mode(gtk4::SelectionMode::Single) .activate_on_single_click(false) .focusable(false) .build(); list.add_css_class("result-list"); let headers: Rc>>> = Rc::new(RefCell::new(Vec::new())); let header_of = headers.clone(); list.set_header_func(move |row, _| { let section = header_of .borrow() .get(row.index() as usize) .copied() .flatten(); match section { Some(section) => row.set_header(Some(§ion.header())), None => row.set_header(gtk4::Widget::NONE), } }); let scroller = gtk4::ScrolledWindow::builder() .hscrollbar_policy(gtk4::PolicyType::Never) .vscrollbar_policy(gtk4::PolicyType::Automatic) .vexpand(true) .child(&list) .build(); scroller.add_css_class("results"); let placeholder = adw::StatusPage::builder() .icon_name("system-search-symbolic") .title(gettext("No results")) .build(); placeholder.add_css_class("compact"); // The daemon-offline page is a peer of the results, not a modal: the prompt // is still usable for nothing else, so it owns the whole view. let offline = adw::StatusPage::builder() .icon_name("network-offline-symbolic") .title(gettext("Proton Drive is not running")) .description(gettext("Start Proton Drive to search your files.")) .build(); offline.add_css_class("compact"); let retry = gtk4::Button::builder() .label(gettext("Retry")) .halign(gtk4::Align::Center) .focus_on_click(false) .build(); retry.add_css_class("pill"); retry.add_css_class("suggested-action"); offline.set_child(Some(&retry)); let stack = gtk4::Stack::builder() .transition_type(gtk4::StackTransitionType::Crossfade) .transition_duration(120) .vexpand(true) .hexpand(true) .build(); stack.add_named(&scroller, Some("results")); stack.add_named(&placeholder, Some("empty")); stack.add_named(&offline, Some("offline")); let preview = Preview::new(); let body = gtk4::Box::new(gtk4::Orientation::Horizontal, 0); body.append(&stack); body.append(>k4::Separator::new(gtk4::Orientation::Vertical)); body.append(&preview.root); card.append(&body); // --- footer ----------------------------------------------------------- let footer = gtk4::Box::new(gtk4::Orientation::Horizontal, 8); footer.add_css_class("footer"); let hint = gtk4::Label::builder() .label(gettext("Connecting…")) .xalign(0.0) .hexpand(true) .ellipsize(gtk4::pango::EllipsizeMode::End) .build(); hint.add_css_class("footer-text"); footer.append(&hint); // Translators: keyboard hints in the footer; keep the arrow and Enter symbols. let keys = gtk4::Label::new(Some(&gettext("↑↓ navigate · ↵ open · Tab filter"))); keys.add_css_class("footer-text"); footer.append(&keys); card.append(&footer); let socket = dirs.control_socket(); let ui = Rc::new_cyclic(|weak: &std::rc::Weak| { let weak = weak.clone(); Ui { thumbs: Thumbs::new(socket.clone()), // A visit recorded elsewhere, or the first load finishing, adds // to the recent list the user may be looking at. history: History::start(dirs.state_dir().join("prompt-history.json"), move || { if let Some(ui) = weak.upgrade() && ui.showing_suggestions() { ui.render(); } }), socket, mountpoint: RefCell::new(dirs.default_mountpoint()), opener: RefCell::new(dirs.load_config().resolved_open_with()), window: window.clone(), entry: entry.clone(), spinner, stack, scroller, list: list.clone(), headers, placeholder, hint, chips: RefCell::new(Vec::new()), preview, previewed: RefCell::new(None), drive_hits: RefCell::new(Vec::new()), local_hits: RefCell::new(Vec::new()), visible: RefCell::new(Vec::new()), cursor: Cell::new(None), rendered_query: RefCell::new(String::new()), filter: Cell::new(Filter::All), query_id: Cell::new(0), pending: Cell::new(0), opening: Cell::new(None), last_ticket: Cell::new(0), indexing: Cell::new(false), open_pending: Cell::new(false), suppress_entry_change: Cell::new(false), } }); for (filter, label) in FILTERS { let chip = gtk4::ToggleButton::builder() .label(gettext(label)) .active(filter == Filter::All) .focus_on_click(false) .build(); chip.add_css_class("chip"); let ui_chip = ui.clone(); chip.connect_clicked(move |btn| { // A chip is a radio, not a switch: clicking the active one keeps it on. if btn.is_active() { ui_chip.set_filter(filter); } else { btn.set_active(true); } }); chip_row.append(&chip); ui.chips.borrow_mut().push((filter, chip)); } // A click selects a row and previews it; a double-click opens it. let ui_selected = ui.clone(); list.connect_row_selected(move |_, row| { if let Some(row) = row { ui_selected.cursor.set(Some(row.index() as usize)); ui_selected.show_preview(); } }); let ui_activated = ui.clone(); list.connect_row_activated(move |_, row| ui_activated.open(row.index() as usize)); let ui_open = ui.clone(); ui.preview .open .connect_clicked(move |_| ui_open.open(ui_open.cursor.get().unwrap_or(0))); let ui_reveal = ui.clone(); ui.preview.reveal.connect_clicked(move |_| { if let Some(index) = ui_reveal.cursor.get() { ui_reveal.show_in_folder(index); } }); let ui_copy = ui.clone(); ui.preview.copy.connect_clicked(move |_| { if let Some(index) = ui_copy.cursor.get() { ui_copy.copy_path(index); } }); let ui_key = ui.clone(); let keys = gtk4::EventControllerKey::new(); keys.connect_key_pressed(move |_, key, _, state| { if ui_key.opening.get().is_some() { // Escape gives up on a Drive file that is still materialising; // everything else waits for it. if key == gdk::Key::Escape { ui_key.cancel_open(); } return glib::Propagation::Stop; } match key { gdk::Key::Escape => { // Spotlight-style: first Escape clears a non-empty query, a // second (or an already-empty box) dismisses the launcher. if ui_key.entry.text().is_empty() { ui_key.dismiss(); } else { ui_key.entry.set_text(""); } glib::Propagation::Stop } gdk::Key::Down => { ui_key.move_cursor(1); glib::Propagation::Stop } gdk::Key::Up => { ui_key.move_cursor(-1); glib::Propagation::Stop } gdk::Key::Tab | gdk::Key::ISO_Left_Tab => { let back = state.contains(gdk::ModifierType::SHIFT_MASK); ui_key.cycle_filter(back); glib::Propagation::Stop } // Return is deliberately absent: `GtkText` binds it to `activate` // and consumes it, so a bubble-phase controller on the window never // sees it while the entry has focus (which is always, here). It is // handled on the entry itself — see below. _ => glib::Propagation::Proceed, } }); window.add_controller(keys); // Enter opens the row under the cursor. This lives on the entry rather than // with the other keys on the window because `GtkText` claims Return for its // own `activate` binding, so a bubble-phase controller upstream of the // focused entry is never reached. let ui_activate = ui.clone(); entry.connect_activate(move |_| { if ui_activate.opening.get().is_some() { return; } // Fall back to the top row when nothing is explicitly selected (e.g. // results haven't rendered yet); `open` guards the rest. ui_activate.open(ui_activate.cursor.get().unwrap_or(0)); }); // Some GTK/input-method combinations consume the physical Return binding in // GtkText without emitting Entry::activate. Capture Return ahead of the text // widget and leave every other key to normal GTK/IME handling. Stopping // propagation also prevents the activate signal above from opening twice; // that signal remains the programmatic/accessibility activation path. // // Ctrl+C is taken here too, but only while the entry has no selection, so // copying part of the query still works; Ctrl+Shift+C always copies the path. let ui_return = ui.clone(); let entry_keys = gtk4::EventControllerKey::new(); entry_keys.set_propagation_phase(gtk4::PropagationPhase::Capture); entry_keys.connect_key_pressed(move |_, key, _, state| { let control = state.contains(gdk::ModifierType::CONTROL_MASK); match key { gdk::Key::Return | gdk::Key::KP_Enter => { if ui_return.opening.get().is_none() { let index = ui_return.cursor.get().unwrap_or(0); if control { ui_return.show_in_folder(index); } else { ui_return.open(index); } } glib::Propagation::Stop } gdk::Key::c | gdk::Key::C if control => { let shift = state.contains(gdk::ModifierType::SHIFT_MASK); if !shift && ui_return.entry.selection_bounds().is_some() { return glib::Propagation::Proceed; } if let Some(index) = ui_return.cursor.get() { ui_return.copy_path(index); } glib::Propagation::Stop } _ => glib::Propagation::Proceed, } }); entry.add_controller(entry_keys); let debounce: Rc>> = Rc::new(RefCell::new(None)); let ui_changed = ui.clone(); entry.connect_changed(move |entry| { if ui_changed.suppress_entry_change.get() { return; } // A fresh keystroke supersedes any Enter that was waiting on results: // the user is still refining the query, not asking to open yet. ui_changed.open_pending.set(false); if let Some(source) = debounce.borrow_mut().take() { source.remove(); } let query = entry.text().trim().to_string(); let ui_timeout = ui_changed.clone(); let debounce_timeout = debounce.clone(); let source = glib::timeout_add_local_once(SEARCH_DEBOUNCE, move || { debounce_timeout.borrow_mut().take(); ui_timeout.search(&query); }); *debounce.borrow_mut() = Some(source); }); let ui_retry = ui.clone(); retry.connect_clicked(move |_| ui_retry.connect()); // Keep the widget tree alive when the compositor asks the window to close. // This also avoids running GTK's destruction path while async replies still // hold references to prompt widgets. let ui_close = ui.clone(); window.connect_close_request(move |_| { ui_close.dismiss(); glib::Propagation::Stop }); let entry_map = entry.clone(); window.connect_map(move |_| { entry_map.grab_focus(); }); Some(ui) } /// Whether the mount has `hit`, without blocking the window /// ([`present_within`]). `None` means "not there" or "no answer"; either way /// the daemon is the fallback. async fn mounted_target_within(mountpoint: PathBuf, hit: SearchHit) -> Option { present_within(mounted_or_relative(&mountpoint, &hit)).await } impl Ui { /// `--preload`: create the surface, renderer and style state now, without /// mapping the window, so the first real summon only has to present it. pub(crate) fn preload(&self) { WidgetExt::realize(&self.window); } /// Reset and present the resident prompt in response to GApplication /// activation. A second invocation while a file is materialising merely /// raises the progress window; it must not make the in-flight open mutable. pub(crate) fn activate(self: &Rc) { if self.opening.get().is_none() { // Preferences may have changed in the app while the launcher was // hidden. if let Ok(dirs) = AppDirs::new() { let config = dirs.load_config(); set_proton_theme(config.proton_theme.unwrap_or(false)); *self.opener.borrow_mut() = config.resolved_open_with(); } self.history.prune(); // Supersede replies from the previous showing before clearing the // query. The daemon work may finish, but it can no longer repaint // the newly activated prompt with stale rows. self.query_id.set(self.query_id.get() + 1); self.pending.set(0); self.open_pending.set(false); self.spinner.set_visible(false); self.suppress_entry_change.set(true); self.entry.set_text(""); self.suppress_entry_change.set(false); self.set_filter(Filter::All); self.connect(); } self.window.present(); self.entry.grab_focus(); } /// Dismiss without destroying the application window. GTK continues to /// associate the hidden window with the single application instance, so a /// later desktop shortcut invocation is a cheap `activate` round-trip. fn dismiss(&self) { self.open_pending.set(false); self.thumbs.cancel_all(); self.window.set_visible(false); } /// Whether the empty-query view is on screen, so a history update may /// repaint it. fn showing_suggestions(&self) -> bool { self.opening.get().is_none() && self.rendered_query.borrow().is_empty() && self.entry.text().trim().is_empty() && self.stack.visible_child_name().as_deref() != Some("offline") } /// Ask the daemon for status and, if it answers, load the suggested (pinned) /// files. Runs off-thread: a dead daemon must not freeze the first frame. fn connect(self: &Rc) { self.hint.set_label(&gettext("Connecting…")); let rx = spawn_request(self.socket.clone(), Request::Status); let ui = self.clone(); glib::spawn_future_local(async move { match rx.recv().await { Ok(Ok(Response::Status { mountpoint, .. })) => { *ui.mountpoint.borrow_mut() = PathBuf::from(mountpoint); ui.entry.set_sensitive(true); ui.stack.set_visible_child_name("results"); ui.load_suggestions(); } _ => { ui.entry.set_sensitive(false); ui.hint.set_label(&gettext("Proton Drive isn't running")); ui.stack.set_visible_child_name("offline"); ui.preview.show(None, &ui.thumbs, &ui.mountpoint.borrow()); } } }); } /// The daemon stopped answering after the window was already open. Flip to /// the offline page and lock the entry; the retry button re-runs `connect`. fn go_offline(self: &Rc) { self.pending.set(0); self.spinner.set_visible(false); self.entry.set_sensitive(false); self.hint.set_label(&gettext("Proton Drive isn't running")); self.stack.set_visible_child_name("offline"); self.preview .show(None, &self.thumbs, &self.mountpoint.borrow()); } /// The empty-query view: recently opened files, then the pinned ones. fn load_suggestions(self: &Rc) { let id = self.begin_query(1); let rx = spawn_request(self.socket.clone(), Request::ListPins); let ui = self.clone(); glib::spawn_future_local(async move { let reply = rx.recv().await; if !ui.finish_query(id) { return; } if matches!(reply, Ok(Err(_)) | Err(_)) { ui.go_offline(); return; } let hits = match reply { Ok(Ok(Response::Pins { pins })) => pins .into_iter() .map(|pin| SearchHit { name: file_name(&pin.path), path: pin.path, is_dir: pin.is_dir.unwrap_or(pin.recursive), size: 0, modified: 0, pinned: true, cached: pin.cached, uid: pin.uid, mounted_path: None, score: 0, }) .collect(), _ => Vec::new(), }; *ui.drive_hits.borrow_mut() = hits; ui.local_hits.borrow_mut().clear(); ui.render(); }); } /// Search Drive and local metadata in one daemon round-trip. An empty query /// falls back to the suggestions view. fn search(self: &Rc, query: &str) { if query.is_empty() { self.load_suggestions(); return; } let id = self.begin_query(1); let search = spawn_request( self.socket.clone(), Request::SearchV2 { query: query.to_string(), limit: SEARCH_LIMIT, filters: SearchFilters { sources: vec![SearchSource::Drive, SearchSource::Local], kind: self.filter.get().search_kind(), }, }, ); let ui = self.clone(); glib::spawn_future_local(async move { let reply = search.recv().await; if !ui.finish_query(id) { return; } match reply { Ok(Ok(Response::SearchResultsV2 { drive_hits, local_hits, local_indexing, })) => { *ui.drive_hits.borrow_mut() = drive_hits; *ui.local_hits.borrow_mut() = local_hits; ui.indexing.set(local_indexing); ui.render(); } // Transport failure: the daemon is gone. Don't paint "No // results" over a crash — say so. Ok(Err(_)) | Err(_) => ui.go_offline(), _ => { ui.drive_hits.borrow_mut().clear(); ui.local_hits.borrow_mut().clear(); ui.render(); } } }); } /// Open a new query id, expecting `requests` replies. Any reply still in /// flight for an older id is now stale and will be dropped by /// [`finish_query`](Self::finish_query). fn begin_query(&self, requests: u8) -> u64 { let id = self.query_id.get() + 1; self.query_id.set(id); self.pending.set(requests); self.spinner.set_visible(true); id } /// Account for one reply. Returns false if it belongs to a superseded query, /// in which case the caller must discard it. fn finish_query(&self, id: u64) -> bool { if self.query_id.get() != id { return false; } let left = self.pending.get().saturating_sub(1); self.pending.set(left); if left == 0 && self.opening.get().is_none() { self.spinner.set_visible(false); } true } fn set_filter(self: &Rc, filter: Filter) { if self.filter.get() == filter { return; } self.filter.set(filter); for (chip_filter, chip) in self.chips.borrow().iter() { chip.set_active(*chip_filter == filter); } let query = self.entry.text().trim().to_string(); if query.is_empty() { self.render(); } else { self.search(&query); } } fn cycle_filter(self: &Rc, backwards: bool) { let current = FILTERS .iter() .position(|(f, _)| *f == self.filter.get()) .unwrap_or(0); let count = FILTERS.len(); let next = if backwards { (current + count - 1) % count } else { (current + 1) % count }; self.set_filter(FILTERS[next].0); } /// The rows for the current state, with the section each one starts. fn rows(&self, query: &str) -> (Vec, Vec>) { let filter = self.filter.get(); let mut hits: Vec = self .drive_hits .borrow() .iter() .filter(|hit| filter.accepts(&hit.name, hit.is_dir)) .cloned() .map(Hit::Drive) .collect(); hits.extend( self.local_hits .borrow() .iter() .filter(|hit| filter.accepts(&hit.name, hit.is_dir)) .cloned() .map(Hit::Local), ); if !query.is_empty() { let bonuses = self.history.bonuses(); rank_hits_by(&mut hits, |hit| { bonuses.get(&hit.key()).copied().unwrap_or_default() }); let mut headers = vec![None; hits.len()]; if let Some(first) = headers.first_mut() { *first = Some(Section::Matches); } return (hits, headers); } // Recent files first, without the pinned files listed below them. let pinned: std::collections::HashSet<(bool, String)> = hits.iter().map(Hit::key).collect(); let recent: Vec = self .history .recent(usize::MAX) .into_iter() .filter(|hit| filter.accepts(hit.name(), hit.is_dir())) .filter(|hit| !pinned.contains(&hit.key())) .take(RECENT_LIMIT) .collect(); let mut headers = vec![None; recent.len() + hits.len()]; if !recent.is_empty() { headers[0] = Some(Section::Recent); } if !hits.is_empty() { headers[recent.len()] = Some(Section::Pinned); } let mut rows = recent; rows.extend(hits); (rows, headers) } /// Rebuild the list, preserving the selected identity when a result /// survives the update. fn render(self: &Rc) { // Identity of the row under the cursor before we rebuild the list, so a // late-arriving second search can't yank the selection back to the top. let selected_key = self .cursor .get() .and_then(|i| self.visible.borrow().get(i).map(Hit::key)); let query = self.entry.text().trim().to_string(); let searching = !query.is_empty(); let (visible, headers) = self.rows(&query); let total = visible.len(); self.thumbs.begin_render(); *self.headers.borrow_mut() = headers; self.cursor.set(None); self.previewed.borrow_mut().take(); self.list.remove_all(); let mountpoint = self.mountpoint.borrow().clone(); for hit in &visible { let row = row::build_row(hit, &query, &self.thumbs, &mountpoint); let ui = Rc::downgrade(self); let dragged = hit.clone(); row::attach_drag(&row, hit.fs_path(&mountpoint), move || { if let Some(ui) = ui.upgrade() { ui.history.record(dragged.clone()); ui.dismiss(); } }); self.list.append(&row); } self.list.invalidate_headers(); self.thumbs.end_render(); // Find where the previously-selected row landed in the rebuilt list. let restored = selected_key.and_then(|key| visible.iter().position(|hit| hit.key() == key)); *self.visible.borrow_mut() = visible; *self.rendered_query.borrow_mut() = query; if total == 0 { self.placeholder.set_title(&if searching { gettext("No results") } else { gettext("Search your Drive") }); self.placeholder .set_description(Some(&match (searching, self.indexing.get()) { (true, true) => gettext( "Still indexing this computer — local results will fill in shortly.", ), (true, false) => gettext("Try a different search, or another filter."), _ => gettext( "Start typing to search Proton Drive and the files on this computer.", ), })); self.stack.set_visible_child_name("empty"); self.preview.show(None, &self.thumbs, &mountpoint); } else { self.stack.set_visible_child_name("results"); self.select(restored.unwrap_or(0)); } self.refresh_hint(); // Honour an Enter that arrived before this query rendered, now that the // results (and the cursor) are settled. if self.open_pending.get() && self.pending.get() == 0 { self.open_pending.set(false); if let Some(index) = self.cursor.get() { self.open(index); } } } /// The footer's summary of what the list shows. fn refresh_hint(&self) { let visible = self.visible.borrow(); let text = if self.rendered_query.borrow().is_empty() { match visible.iter().filter(|hit| hit.pinned()).count() { 0 => gettext("No pinned files"), n => ngettext_f("{n} pinned file", "{n} pinned files", n as u64, &[]), } } else { let drive_count = visible .iter() .filter(|hit| matches!(hit, Hit::Drive(_))) .count(); let drive = drive_count.to_string(); let local = (visible.len() - drive_count).to_string(); let args = [("drive", drive.as_str()), ("local", local.as_str())]; if self.indexing.get() { // Translators: result counts in the footer while this computer is still being indexed; {drive} and {local} are numbers. gettext_f( "{drive} in Drive · {local} on this computer · indexing…", &args, ) } else { // Translators: result counts in the footer; {drive} and {local} are numbers. gettext_f("{drive} in Drive · {local} on this computer", &args) } }; self.hint.set_label(&text); } /// Move the cursor by `delta` rows, wrapping at both ends. fn move_cursor(self: &Rc, delta: i32) { let count = self.visible.borrow().len() as i32; if count == 0 { return; } let current = self.cursor.get().map_or(0, |c| c as i32); let next = (current + delta).rem_euclid(count); self.select(next as usize); } /// Put the cursor on row `index`, preview it and scroll it into view. /// Focus stays in the entry so typing never breaks. fn select(self: &Rc, index: usize) { let Some(row) = self.list.row_at_index(index as i32) else { return; }; self.list.select_row(Some(&row)); self.cursor.set(Some(index)); self.show_preview(); self.scroll_into_view(&row); } fn show_preview(&self) { let hit = self .cursor .get() .and_then(|index| self.visible.borrow().get(index).cloned()); let key = hit.as_ref().map(Hit::key); if *self.previewed.borrow() == key && key.is_some() { return; } *self.previewed.borrow_mut() = key; self.preview .show(hit.as_ref(), &self.thumbs, &self.mountpoint.borrow()); } /// Keep the selected row inside the viewport, scrolling by the smallest /// amount that reveals it (like a native list, unlike jumping it to centre). /// A section header above the first row of a section counts as part of it. fn scroll_into_view(&self, row: >k4::ListBoxRow) { let target = row.header().unwrap_or_else(|| row.clone().upcast()); let (Some(top), Some(bottom)) = ( target.compute_bounds(&self.list), row.compute_bounds(&self.list), ) else { return; }; let adjustment = self.scroller.vadjustment(); let (top, bottom) = (f64::from(top.y()), f64::from(bottom.y() + bottom.height())); let (value, page) = (adjustment.value(), adjustment.page_size()); if top < value { adjustment.set_value(top); } else if bottom > value + page { adjustment.set_value(bottom - page); } } /// The hit at `index`, if it belongs to the query on screen. The rows may /// still show an older query whose reply is settling; nothing may act on /// them then. fn current_hit(&self, index: usize) -> Option { if self.entry.text().trim() != *self.rendered_query.borrow() { return None; } self.visible.borrow().get(index).cloned() } /// Hand a path to the configured opener — `xdg-open` unless `open_with` in /// `config.json` says otherwise — remember the visit, and close. fn launch(&self, hit: &Hit, path: &Path, is_dir: bool) { opener::open(&self.opener.borrow(), path, is_dir); self.history.record(hit.clone()); self.dismiss(); } /// Open the hit at `index`. Local files are already on disk, so they hand /// straight to the desktop. A Drive file opens from the mount when the /// mount has it, and is otherwise materialised by the daemon (`OpenFile`), /// which can take a moment — the window stays up, with the spinner /// running, until the path comes back or Escape gives up on it. fn open(self: &Rc, index: usize) { if self.opening.get().is_some() { return; } // Enter must never launch a file the user has typed past. But don't // drop the intent either: remember it and open the right row once the // fresh results land (see `render`). if self.entry.text().trim() != *self.rendered_query.borrow() { self.open_pending.set(true); return; } let Some(hit) = self.current_hit(index) else { return; }; let drive = match &hit { Hit::Local(local) => { self.launch(&hit, Path::new(&local.path), local.is_dir); return; } Hit::Drive(drive) => drive.clone(), }; // Pins come from ListPins, whose `recursive` flag is pin policy rather // than reliable node kind metadata. Every pin already has a mounted // path, so activate that path directly; this handles non-recursively // pinned folders without mistaking them for files and sending an // invalid OpenFile request. let pin_row = self.rendered_query.borrow().is_empty() && drive.pinned; if pin_row || matches!( drive_activation(&drive.name, drive.is_dir), DriveActivation::Folder | DriveActivation::MountedMedia ) { let path = mounted_or_relative(&self.mountpoint.borrow(), &drive); self.launch(&hit, &path, drive.is_dir); return; } let ticket = self.last_ticket.get() + 1; self.last_ticket.set(ticket); self.opening.set(Some(ticket)); self.spinner.set_visible(true); // Translators: {name} is a file name. let opening = gettext_f("Opening {name}…", &[("name", &drive.name)]); self.hint.set_label(&opening); let mountpoint = self.mountpoint.borrow().clone(); let ui = self.clone(); glib::spawn_future_local(async move { // The mount holds the real file; the cache holds a copy an editor // would save into for nothing. Prefer the mount, and materialise // only what it does not expose. if let Some(path) = mounted_target_within(mountpoint, drive.clone()).await { if ui.finish_open(ticket) { ui.launch(&hit, &path, false); } return; } if ui.opening.get() != Some(ticket) { return; } let rx = spawn_request( ui.socket.clone(), Request::OpenFile { path: drive.path.clone(), uid: Some(drive.uid.clone()), }, ); let reply = rx.recv().await; if !ui.finish_open(ticket) { return; } match reply { Ok(Ok(Response::FilePath { path })) => { // The blob is named after its content hash, so the open // rules have to be matched against the Drive name instead. opener::open_named(&ui.opener.borrow(), Path::new(&path), &drive.name, false); ui.history.record(hit.clone()); ui.dismiss(); } Ok(Ok(Response::Error { message, .. })) => { // Translators: {message} is an error from the daemon, in English. ui.hint.set_label(&gettext_f( "Could not open: {message}", &[("message", &message)], )); } _ => ui.hint.set_label(&gettext("Couldn't reach Proton Drive")), } }); } /// End the open with `ticket`. False when it was cancelled or superseded, /// in which case the caller must not launch anything. fn finish_open(&self, ticket: u64) -> bool { if self.opening.get() != Some(ticket) { return false; } self.opening.set(None); self.spinner.set_visible(self.pending.get() > 0); true } /// Give up on the Drive open in progress. The daemon may still finish /// materialising the file, but it is not launched. fn cancel_open(&self) { self.opening.set(None); self.spinner.set_visible(self.pending.get() > 0); self.refresh_hint(); } /// Show the hit at `index` selected in the file manager, through the /// freedesktop `FileManager1` interface, or open its folder when no file /// manager offers that. fn show_in_folder(self: &Rc, index: usize) { if self.opening.get().is_some() { return; } let Some(hit) = self.current_hit(index) else { return; }; let path = hit.fs_path(&self.mountpoint.borrow()); let uri = gio::File::for_path(&path).uri().to_string(); let Some(connection) = self .window .application() .and_then(|app| app.dbus_connection()) else { self.open_parent(&hit, &path); return; }; let ui = self.clone(); glib::spawn_future_local(async move { let shown = connection .call_future( Some("org.freedesktop.FileManager1"), "/org/freedesktop/FileManager1", "org.freedesktop.FileManager1", "ShowItems", Some(&(vec![uri], String::new()).to_variant()), None, gio::DBusCallFlags::NONE, 2000, ) .await; match shown { Ok(_) => { ui.history.record(hit); ui.dismiss(); } Err(e) => { tracing::debug!("FileManager1.ShowItems failed: {e}"); ui.open_parent(&hit, &path); } } }); } fn open_parent(&self, hit: &Hit, path: &Path) { let Some(parent) = path.parent() else { return; }; opener::open(&self.opener.borrow(), parent, true); self.history.record(hit.clone()); self.dismiss(); } /// Copy the path of the hit at `index`: the file itself for a local hit, /// its place in the mount for a Drive hit. fn copy_path(&self, index: usize) { let Some(hit) = self.current_hit(index) else { return; }; let path = hit.fs_path(&self.mountpoint.borrow()); self.entry.clipboard().set_text(&path.display().to_string()); self.preview.flash_copied(); } }