mirror of
https://github.com/narrrl/proton-drive-linux.git
synced 2026-11-17 17:55:03 +01:00
Back, Forward and Up in My files restore the folder's scroll offset and selection as they were when it was left; opening a folder any other way still starts at the top. Closing the photo viewer scrolls the grid to the photo it showed last. Alt+Left and Backspace go back a level in Shared with me and Computers and leave an open album or place; Escape leaves an album or place too, after ending selection mode. The shortcuts window lists it. A fresh Photos load, or leaving the grid for Albums or Places, ends a scrubber jump that was still paging.
1455 lines
55 KiB
Rust
1455 lines
55 KiB
Rust
use crate::*;
|
|
|
|
pub(crate) struct DevicesState {
|
|
// Computers page: one list of the account's computers, this one first, and
|
|
// a read-only browser over another computer's backup.
|
|
/// "list", "browse", or "status" while the page loads or can't be read.
|
|
pub(crate) content: gtk4::Stack,
|
|
pub(crate) status: adw::StatusPage,
|
|
pub(crate) retry: gtk4::Button,
|
|
pub(crate) group: adw::PreferencesGroup,
|
|
/// Rows added last time, removed before the next paint (adw groups have no
|
|
/// clear-all).
|
|
pub(crate) rows: RefCell<Vec<gtk4::Widget>>,
|
|
/// The browse view's files.
|
|
pub(crate) files: FileList,
|
|
/// The browse view: "list", or "empty".
|
|
pub(crate) files_content: gtk4::Stack,
|
|
/// The breadcrumb trail from "Computers" down to the current folder.
|
|
pub(crate) crumb: gtk4::Box,
|
|
/// Grid or list for the browse view; hidden on the device list.
|
|
pub(crate) layout: gtk4::Button,
|
|
/// Where the browse view is, as `(uid, name)`: the computer first, then each
|
|
/// folder below it. Empty = the device list. A backup has no path in the
|
|
/// mount, so descending is uid-addressed and the stack is the breadcrumb.
|
|
pub(crate) nav: RefCell<Vec<(String, String)>>,
|
|
/// The [`DevicesState::nav`] the page on screen was painted for, or `None`
|
|
/// before the first paint.
|
|
pub(crate) listed: RefCell<Option<Vec<(String, String)>>>,
|
|
/// Runs the loads; the rows stay up while one runs.
|
|
pub(crate) loader: Rc<Loader>,
|
|
}
|
|
|
|
impl DevicesState {
|
|
pub(crate) fn new(widgets: &DevicesWidgets) -> Self {
|
|
DevicesState {
|
|
content: widgets.content.clone(),
|
|
status: widgets.status.clone(),
|
|
retry: widgets.retry.clone(),
|
|
group: widgets.group.clone(),
|
|
rows: RefCell::new(Vec::new()),
|
|
files: widgets.files.clone(),
|
|
files_content: widgets.files_content.clone(),
|
|
crumb: widgets.crumb.clone(),
|
|
layout: widgets.layout.clone(),
|
|
nav: RefCell::new(Vec::new()),
|
|
listed: RefCell::new(None),
|
|
loader: Loader::new(&widgets.content),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Widgets the Devices page's load/repaint touch.
|
|
pub(crate) struct DevicesWidgets {
|
|
pub(crate) content: gtk4::Stack,
|
|
pub(crate) status: adw::StatusPage,
|
|
/// Every computer on the account, this one first.
|
|
pub(crate) group: adw::PreferencesGroup,
|
|
pub(crate) files: FileList,
|
|
pub(crate) files_content: gtk4::Stack,
|
|
/// Goes up one folder, and from a computer's top level back to the list.
|
|
pub(crate) back: gtk4::Button,
|
|
pub(crate) crumb: gtk4::Box,
|
|
pub(crate) layout: gtk4::Button,
|
|
pub(crate) retry: gtk4::Button,
|
|
}
|
|
|
|
/// The Computers page: every computer backing up to the account, with this one
|
|
/// first. This computer's row leads to its folders on the Sync page; another
|
|
/// computer's row opens its backup read-only, in the same list as My files.
|
|
pub(crate) fn build_devices_page() -> (gtk4::Widget, DevicesWidgets) {
|
|
let group = adw::PreferencesGroup::new();
|
|
let clamp = adw::Clamp::builder().child(&group).build();
|
|
let scroll = gtk4::ScrolledWindow::builder()
|
|
.vexpand(true)
|
|
.child(&clamp)
|
|
.build();
|
|
|
|
// Browse: a path bar over the list, as on Shared with me.
|
|
let files = FileList::new();
|
|
files.show_list(true);
|
|
let layout = layout_button(&files);
|
|
layout.set_visible(false);
|
|
let back = gtk4::Button::builder()
|
|
.icon_name("go-previous-symbolic")
|
|
.tooltip_text(gettext("Back"))
|
|
.build();
|
|
back.add_css_class("flat");
|
|
let crumb = gtk4::Box::new(gtk4::Orientation::Horizontal, 2);
|
|
crumb.set_valign(gtk4::Align::Center);
|
|
let crumb_scroll = gtk4::ScrolledWindow::builder()
|
|
.hscrollbar_policy(gtk4::PolicyType::External)
|
|
.vscrollbar_policy(gtk4::PolicyType::Never)
|
|
.hexpand(true)
|
|
.child(&crumb)
|
|
.build();
|
|
let path_bar = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
|
|
path_bar.append(&back);
|
|
path_bar.append(&crumb_scroll);
|
|
let files_empty = adw::StatusPage::builder()
|
|
.icon_name("folder-open-symbolic")
|
|
.title(gettext("This folder is empty"))
|
|
.description(gettext("Nothing in this folder has been backed up."))
|
|
.vexpand(true)
|
|
.build();
|
|
files_empty.add_css_class("compact");
|
|
let files_content = gtk4::Stack::new();
|
|
files_content.add_named(&files.views, Some("list"));
|
|
files_content.add_named(&files_empty, Some("empty"));
|
|
let browse = gtk4::Box::new(gtk4::Orientation::Vertical, 12);
|
|
browse.append(&path_bar);
|
|
browse.append(&files_content);
|
|
|
|
let retry = gtk4::Button::builder()
|
|
.label(gettext("Retry"))
|
|
.halign(gtk4::Align::Center)
|
|
.build();
|
|
retry.add_css_class("pill");
|
|
retry.add_css_class("suggested-action");
|
|
retry.set_visible(false);
|
|
let status = adw::StatusPage::builder()
|
|
.icon_name("computer-symbolic")
|
|
.vexpand(true)
|
|
.child(&retry)
|
|
.build();
|
|
status.add_css_class("compact");
|
|
|
|
let content = gtk4::Stack::new();
|
|
content.set_vexpand(true);
|
|
content.set_transition_type(gtk4::StackTransitionType::Crossfade);
|
|
content.add_named(&scroll, Some("list"));
|
|
content.add_named(&browse, Some("browse"));
|
|
content.add_named(&status, Some("status"));
|
|
|
|
let inner = gtk4::Box::new(gtk4::Orientation::Vertical, 12);
|
|
inner.set_margin_top(18);
|
|
inner.set_margin_bottom(18);
|
|
inner.set_margin_start(18);
|
|
inner.set_margin_end(18);
|
|
inner.append(&content);
|
|
let (frame, header, _) = page_frame(&gettext("Computers"), &inner);
|
|
header.pack_end(&layout);
|
|
|
|
(
|
|
frame.upcast(),
|
|
DevicesWidgets {
|
|
content,
|
|
status,
|
|
group,
|
|
files,
|
|
files_content,
|
|
back,
|
|
crumb,
|
|
layout,
|
|
retry,
|
|
},
|
|
)
|
|
}
|
|
|
|
/// Install the browse view's file list and the page's buttons.
|
|
pub(crate) fn wire_devices(ui: &Rc<Ui>, widgets: &DevicesWidgets) {
|
|
let files = &ui.devices.files;
|
|
files.wire(
|
|
ui,
|
|
FileListBehavior {
|
|
activate: open_device_entry,
|
|
entry_menu: device_entry_menu,
|
|
bulk_menu: device_bulk_menu,
|
|
background_menu: device_background_menu,
|
|
badges: false,
|
|
drag_and_drop: false,
|
|
},
|
|
);
|
|
files
|
|
.column_view
|
|
.append_column(&text_column(&pgettext("column", "Modified"), |e| {
|
|
if e.modified > 0 {
|
|
dates::short_date(e.modified)
|
|
} else {
|
|
"—".to_string()
|
|
}
|
|
}));
|
|
files
|
|
.column_view
|
|
.append_column(&text_column(&pgettext("column", "Size"), |e| {
|
|
if e.is_dir {
|
|
"—".to_string()
|
|
} else {
|
|
human_bytes(e.size)
|
|
}
|
|
}));
|
|
|
|
let ui_back = ui.clone();
|
|
widgets
|
|
.back
|
|
.connect_clicked(move |_| devices_back(&ui_back));
|
|
let ui_retry = ui.clone();
|
|
widgets
|
|
.retry
|
|
.connect_clicked(move |_| restart_service_then(&ui_retry, load_devices));
|
|
}
|
|
|
|
/// Show a status page in place of the Devices list.
|
|
pub(crate) fn devices_status(ui: &Rc<Ui>, icon: &str, title: &str, description: &str, retry: bool) {
|
|
ui.devices.status.set_icon_name(Some(icon));
|
|
ui.devices.status.set_title(title);
|
|
ui.devices
|
|
.status
|
|
.set_description(Some(>k4::glib::markup_escape_text(description)));
|
|
ui.devices.retry.set_visible(retry);
|
|
ui.devices.content.set_visible_child_name("status");
|
|
}
|
|
|
|
/// Back out of a computer's folder to the level above: the page's Back button, and
|
|
/// Alt+Left or Backspace. A no-op at the top.
|
|
pub(crate) fn devices_back(ui: &Rc<Ui>) {
|
|
if ui.devices.nav.borrow_mut().pop().is_some() {
|
|
load_devices(ui);
|
|
}
|
|
}
|
|
|
|
/// Load the view [`DevicesState::nav`] points at: the device list, or a folder
|
|
/// of another computer's backup.
|
|
pub(crate) fn load_devices(ui: &Rc<Ui>) {
|
|
cancel_file_thumbnails(ui);
|
|
let nav = ui.devices.nav.borrow().clone();
|
|
ui.devices.layout.set_visible(!nav.is_empty());
|
|
if !nav.is_empty() {
|
|
load_device_folder(ui, &nav);
|
|
return;
|
|
}
|
|
let ticket = begin_devices_load(ui, "computer-symbolic", gettext("Reading your computers."));
|
|
ui.busy_begin();
|
|
// The two lists are independent and the daemon serves requests concurrently,
|
|
// so fire both up front and collect them, rather than paying two round trips
|
|
// back to back.
|
|
let rx = spawn_request(ui.dirs.control_socket(), Request::ListSyncFolders);
|
|
let rx2 = spawn_request(ui.dirs.control_socket(), Request::ListDevices);
|
|
let ui = ui.clone();
|
|
glib::spawn_future_local(async move {
|
|
let sync = rx.recv().await;
|
|
let devices_reply = rx2.recv().await;
|
|
ui.busy_end();
|
|
if !ticket.is_current() {
|
|
return;
|
|
}
|
|
let folders = match sync {
|
|
Ok(Ok(Response::SyncFolders { items })) => items,
|
|
// The daemon answered but not as expected — treat as empty and carry
|
|
// on to the devices list rather than failing the whole page.
|
|
Ok(Ok(_)) => Vec::new(),
|
|
Ok(Err(_)) | Err(_) => {
|
|
devices_unreachable(&ui);
|
|
return;
|
|
}
|
|
};
|
|
let devices = match devices_reply {
|
|
Ok(Ok(Response::Devices { items })) => items,
|
|
_ => Vec::new(),
|
|
};
|
|
ui.devices.content.set_visible_child_name("list");
|
|
repaint_devices(&ui, &devices, &folders);
|
|
repaint_device_crumb(&ui, &[]);
|
|
*ui.devices.listed.borrow_mut() = Some(Vec::new());
|
|
});
|
|
}
|
|
|
|
/// List one folder of another computer's backup. The computer's own top level
|
|
/// is its restorable folders; below that, any folder lists by uid.
|
|
fn load_device_folder(ui: &Rc<Ui>, nav: &[(String, String)]) {
|
|
let ticket = begin_devices_load(ui, "folder-symbolic", gettext("Reading this folder."));
|
|
ui.busy_begin();
|
|
let (uid, _) = nav.last().cloned().unwrap_or_default();
|
|
let request = if nav.len() == 1 {
|
|
Request::ListDeviceRestorableFolders { device: uid }
|
|
} else {
|
|
Request::ListSharedFolder { uid }
|
|
};
|
|
let rx = spawn_request(ui.dirs.control_socket(), request);
|
|
let ui = ui.clone();
|
|
let nav = nav.to_vec();
|
|
glib::spawn_future_local(async move {
|
|
let result = rx.recv().await;
|
|
ui.busy_end();
|
|
if !ticket.is_current() {
|
|
return;
|
|
}
|
|
let entries = match result {
|
|
Ok(Ok(Response::Entries { entries })) => entries,
|
|
Ok(Ok(Response::RestorableFolders { items })) => {
|
|
items.into_iter().map(restorable_entry).collect()
|
|
}
|
|
Ok(Ok(Response::Error { message, kind })) => {
|
|
// The folder or the computer is gone: fall back a level rather
|
|
// than stranding the page on a dead uid.
|
|
ui.devices.nav.borrow_mut().pop();
|
|
toast_failure(&ui, &gettext("Couldn't open folder"), &message, kind);
|
|
load_devices(&ui);
|
|
return;
|
|
}
|
|
_ => {
|
|
devices_unreachable(&ui);
|
|
return;
|
|
}
|
|
};
|
|
ui.devices.content.set_visible_child_name("browse");
|
|
repaint_device_crumb(&ui, &nav);
|
|
let another_folder = ui.devices.listed.borrow().as_ref() != Some(&nav);
|
|
*ui.devices.listed.borrow_mut() = Some(nav);
|
|
if entries.is_empty() {
|
|
ui.devices.files.model.remove_all();
|
|
ui.devices.files_content.set_visible_child_name("empty");
|
|
} else {
|
|
ui.devices.files_content.set_visible_child_name("list");
|
|
replace_items(&ui.devices.files.model, &entries);
|
|
// A refresh keeps its place; another folder starts at the top.
|
|
if another_folder {
|
|
ui.devices.files.scroll_to_top();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/// A computer's top-level folder as a browsable entry.
|
|
fn restorable_entry(folder: RestorableFolder) -> DirEntry {
|
|
DirEntry {
|
|
name: folder.name,
|
|
is_dir: true,
|
|
uid: folder.remote_uid,
|
|
..DirEntry::default()
|
|
}
|
|
}
|
|
|
|
/// Start a load of the view [`DevicesState::nav`] points at. A reload of the
|
|
/// view on screen keeps it up and usable; moving elsewhere greys it out until
|
|
/// the new view arrives.
|
|
fn begin_devices_load(ui: &Rc<Ui>, icon: &'static str, description: String) -> LoadTicket {
|
|
let ui_p = ui.clone();
|
|
let placeholder = move || {
|
|
devices_status(&ui_p, icon, &gettext("Loading…"), &description, false);
|
|
};
|
|
if *ui.devices.listed.borrow() == Some(ui.devices.nav.borrow().clone()) {
|
|
ui.devices.loader.refresh(placeholder)
|
|
} else {
|
|
ui.devices.listed.borrow_mut().take();
|
|
ui.devices.loader.replace(placeholder)
|
|
}
|
|
}
|
|
|
|
/// The daemon didn't answer the Devices page.
|
|
pub(crate) fn devices_unreachable(ui: &Rc<Ui>) {
|
|
service_unreachable(ui, "devices", devices_status, load_devices);
|
|
}
|
|
|
|
/// Rebuild the device list: this computer first, then the others.
|
|
///
|
|
/// This computer's row offers no Remove. Deleting a device deletes its root
|
|
/// folder — every file backed up from it — and for this machine that would also
|
|
/// pull the ground out from under its synced folders, so it is not offered as a
|
|
/// peer of "remove some other laptop". Removing this computer's backup means
|
|
/// removing its folders, each of which asks about its cloud copy on its own
|
|
/// terms.
|
|
pub(crate) fn repaint_devices(ui: &Rc<Ui>, devices: &[DeviceInfo], folders: &[SyncFolderInfo]) {
|
|
for row in ui.devices.rows.borrow_mut().drain(..) {
|
|
ui.devices.group.remove(&row);
|
|
}
|
|
let mut rows: Vec<gtk4::Widget> = Vec::new();
|
|
let me = devices.iter().find(|d| d.this_device);
|
|
rows.push(this_computer_row(ui, me, folders).upcast());
|
|
let others: Vec<&DeviceInfo> = devices.iter().filter(|d| !d.this_device).collect();
|
|
for dev in &others {
|
|
rows.push(other_computer_row(ui, dev).upcast());
|
|
}
|
|
if others.is_empty() {
|
|
let row = adw::ActionRow::builder()
|
|
.title(gettext("No other computers"))
|
|
.subtitle(gettext(
|
|
"Install Proton Drive on another computer to see it here.",
|
|
))
|
|
.build();
|
|
row.add_prefix(>k4::Image::from_icon_name("computer-symbolic"));
|
|
let get = gtk4::LinkButton::with_label(PROTON_DRIVE_DOWNLOAD, &gettext("Get Proton Drive"));
|
|
get.set_valign(gtk4::Align::Center);
|
|
row.add_suffix(&get);
|
|
rows.push(row.upcast());
|
|
}
|
|
for row in &rows {
|
|
ui.devices.group.add(row);
|
|
}
|
|
*ui.devices.rows.borrow_mut() = rows;
|
|
}
|
|
|
|
/// Where the Proton Drive apps for other systems are.
|
|
const PROTON_DRIVE_DOWNLOAD: &str = "https://proton.me/drive/download";
|
|
|
|
/// This computer's row: its device name with a "This computer" pill, and how
|
|
/// many folders it backs up. It leads to those folders on the Sync page, which
|
|
/// owns every local path. `me` is `None` until the daemon has registered this
|
|
/// machine as a device.
|
|
fn this_computer_row(
|
|
ui: &Rc<Ui>,
|
|
me: Option<&DeviceInfo>,
|
|
folders: &[SyncFolderInfo],
|
|
) -> adw::ActionRow {
|
|
let row = adw::ActionRow::builder()
|
|
.title(me.map_or_else(|| gettext("This computer"), |d| d.name.clone()))
|
|
.subtitle(this_computer_subtitle(folders))
|
|
.use_markup(false)
|
|
.activatable(true)
|
|
.build();
|
|
row.add_prefix(>k4::Image::from_icon_name("computer-symbolic"));
|
|
if me.is_some() {
|
|
let pill = gtk4::Label::new(Some(&gettext("This computer")));
|
|
pill.add_css_class("role-pill");
|
|
pill.add_css_class("caption");
|
|
pill.set_valign(gtk4::Align::Center);
|
|
row.add_suffix(&pill);
|
|
}
|
|
let mut menu = ActionMenu::new();
|
|
if let Some(me) = me {
|
|
let (ui_c, uid, name) = (ui.clone(), me.uid.clone(), me.name.clone());
|
|
menu.item(&gettext("Rename…"), move || {
|
|
prompt_rename_device(&ui_c, &uid, &name)
|
|
});
|
|
}
|
|
let ui_c = ui.clone();
|
|
menu.item(&gettext("Restore Folders…"), move || {
|
|
prompt_restore_folders(&ui_c, None)
|
|
});
|
|
row.add_suffix(&menu.button());
|
|
row.add_suffix(>k4::Image::from_icon_name("go-next-symbolic"));
|
|
let ui_c = ui.clone();
|
|
row.connect_activated(move |_| {
|
|
ui_c.locations.views.set_visible_child_name("folders");
|
|
ui_c.stack.set_visible_child_name("locations");
|
|
});
|
|
row
|
|
}
|
|
|
|
/// Another computer's row. Opening it browses that computer's backup.
|
|
fn other_computer_row(ui: &Rc<Ui>, dev: &DeviceInfo) -> adw::ActionRow {
|
|
let row = adw::ActionRow::builder()
|
|
.title(&dev.name)
|
|
.subtitle(device_subtitle(dev))
|
|
.use_markup(false)
|
|
.activatable(true)
|
|
.build();
|
|
row.add_prefix(>k4::Image::from_icon_name("computer-symbolic"));
|
|
let (uid, name) = (dev.uid.clone(), dev.name.clone());
|
|
let mut menu = ActionMenu::new();
|
|
let (ui_c, uid_c, name_c) = (ui.clone(), uid.clone(), name.clone());
|
|
menu.item(&gettext("Browse Files"), move || {
|
|
browse_device(&ui_c, &uid_c, &name_c)
|
|
});
|
|
let (ui_c, uid_c, name_c) = (ui.clone(), uid.clone(), name.clone());
|
|
menu.item(&gettext("Restore to This Computer…"), move || {
|
|
prompt_restore_folders(&ui_c, Some((uid_c.clone(), name_c.clone())))
|
|
});
|
|
let (ui_c, uid_c, name_c) = (ui.clone(), uid.clone(), name.clone());
|
|
menu.item(&gettext("Sync With This Computer…"), move || {
|
|
prompt_join_device(&ui_c, &uid_c, &name_c)
|
|
});
|
|
let (ui_c, uid_c, name_c) = (ui.clone(), uid.clone(), name.clone());
|
|
menu.item(&gettext("Move to This Computer…"), move || {
|
|
prompt_migrate_device(&ui_c, &uid_c, &name_c)
|
|
});
|
|
menu.section();
|
|
let (ui_c, uid_c, name_c) = (ui.clone(), uid.clone(), name.clone());
|
|
menu.item(&gettext("Rename…"), move || {
|
|
prompt_rename_device(&ui_c, &uid_c, &name_c)
|
|
});
|
|
// Adoption is how a reinstalled or renamed machine re-attaches to the device
|
|
// it used to be, instead of registering a duplicate. It only makes sense on
|
|
// another computer's row.
|
|
let (ui_c, uid_c, name_c) = (ui.clone(), uid.clone(), name.clone());
|
|
menu.item(&gettext("Continue This Backup Here…"), move || {
|
|
prompt_adopt_device(&ui_c, &uid_c, &name_c)
|
|
});
|
|
menu.section();
|
|
let (ui_c, uid_c, name_c) = (ui.clone(), uid.clone(), name.clone());
|
|
menu.item(&gettext("Remove…"), move || {
|
|
prompt_remove_device(&ui_c, &uid_c, &name_c)
|
|
});
|
|
row.add_suffix(&menu.button());
|
|
row.add_suffix(>k4::Image::from_icon_name("go-next-symbolic"));
|
|
let ui_c = ui.clone();
|
|
row.connect_activated(move |_| browse_device(&ui_c, &uid, &name));
|
|
row
|
|
}
|
|
|
|
/// Open another computer's backup at its top level.
|
|
fn browse_device(ui: &Rc<Ui>, uid: &str, name: &str) {
|
|
*ui.devices.nav.borrow_mut() = vec![(uid.to_string(), name.to_string())];
|
|
load_devices(ui);
|
|
}
|
|
|
|
/// Rebuild the breadcrumb trail for `nav`: "Computers", then the computer and
|
|
/// each folder down to the current one, which is a plain heading.
|
|
fn repaint_device_crumb(ui: &Rc<Ui>, nav: &[(String, String)]) {
|
|
let crumb = &ui.devices.crumb;
|
|
while let Some(child) = crumb.first_child() {
|
|
crumb.remove(&child);
|
|
}
|
|
crumb.append(&device_crumb_node(
|
|
ui,
|
|
&gettext("Computers"),
|
|
0,
|
|
nav.is_empty(),
|
|
));
|
|
for (i, (_, name)) in nav.iter().enumerate() {
|
|
crumb.append(&crumb_separator());
|
|
crumb.append(&device_crumb_node(ui, name, i + 1, i + 1 == nav.len()));
|
|
}
|
|
}
|
|
|
|
/// One breadcrumb segment: a heading for the current folder, or a flat button
|
|
/// that goes back up to `depth` levels below the device list.
|
|
fn device_crumb_node(ui: &Rc<Ui>, label: &str, depth: usize, current: bool) -> gtk4::Widget {
|
|
if current {
|
|
return crumb_current(label);
|
|
}
|
|
let button = gtk4::Button::builder().label(label).build();
|
|
button.add_css_class("flat");
|
|
let ui = ui.clone();
|
|
button.connect_clicked(move |_| {
|
|
ui.devices.nav.borrow_mut().truncate(depth);
|
|
load_devices(&ui);
|
|
});
|
|
button.upcast()
|
|
}
|
|
|
|
/// Folders open in place; files download and open with the default app.
|
|
fn open_device_entry(ui: &Rc<Ui>, entry: &DirEntry) {
|
|
if entry.is_dir {
|
|
ui.devices
|
|
.nav
|
|
.borrow_mut()
|
|
.push((entry.uid.clone(), entry.name.clone()));
|
|
load_devices(ui);
|
|
} else {
|
|
open_shared_file(ui, &entry.uid, &entry.name);
|
|
}
|
|
}
|
|
|
|
fn device_entry_menu(ui: &Rc<Ui>, entry: &DirEntry) -> ActionMenu {
|
|
let mut menu = ActionMenu::new();
|
|
let (ui_c, entry_c) = (ui.clone(), entry.clone());
|
|
menu.item(&pgettext("verb", "Open"), move || {
|
|
open_device_entry(&ui_c, &entry_c)
|
|
});
|
|
menu
|
|
}
|
|
|
|
fn device_bulk_menu(_ui: &Rc<Ui>, entries: Vec<DirEntry>) -> ActionMenu {
|
|
let mut menu = ActionMenu::new();
|
|
menu.labelled_section(&ngettext_f(
|
|
"{n} selected",
|
|
"{n} selected",
|
|
entries.len() as u64,
|
|
&[],
|
|
));
|
|
menu
|
|
}
|
|
|
|
fn device_background_menu(ui: &Rc<Ui>) -> ActionMenu {
|
|
let mut menu = ActionMenu::new();
|
|
let ui_c = ui.clone();
|
|
menu.item(&gettext("Select All"), move || {
|
|
ui_c.devices.files.selection.select_all();
|
|
});
|
|
let ui_c = ui.clone();
|
|
menu.item(&gettext("Refresh"), move || reload_current_page(&ui_c));
|
|
menu
|
|
}
|
|
|
|
/// A device row's subtitle: its platform, and when it last backed up. A device
|
|
/// that never did says so — an unexplained missing date reads as a bug, and
|
|
/// "no backups yet" is the fact that tells the user this computer isn't backing
|
|
/// anything up.
|
|
pub(crate) fn device_subtitle(dev: &DeviceInfo) -> String {
|
|
let platform = platform_label(&dev.device_type);
|
|
match dev.last_sync {
|
|
// Translators: {platform} is the device's platform (such as "Linux"), {time} a relative time such as "5 minutes ago".
|
|
Some(secs) if secs > 0 => gettext_f(
|
|
"{platform} · last backup {time}",
|
|
&[("platform", platform), ("time", &dates::relative(secs))],
|
|
),
|
|
// Translators: {platform} is the device's platform, such as "Linux".
|
|
_ => gettext_f("{platform} · no backups yet", &[("platform", platform)]),
|
|
}
|
|
}
|
|
|
|
/// The platform as its maker spells it. The API's names are enum variants.
|
|
fn platform_label(device_type: &str) -> &str {
|
|
match device_type {
|
|
"MacOs" => "macOS",
|
|
other => other,
|
|
}
|
|
}
|
|
|
|
/// How many folders this machine backs up, and whether any of them needs
|
|
/// attention — the one fact worth surfacing away from the folder list itself.
|
|
pub(crate) fn this_computer_subtitle(folders: &[SyncFolderInfo]) -> String {
|
|
let folders: Vec<_> = folders.iter().filter(|f| f.kind == "device").collect();
|
|
if folders.is_empty() {
|
|
return gettext("No folders backed up yet");
|
|
}
|
|
let count = ngettext_f(
|
|
"{n} folder backed up",
|
|
"{n} folders backed up",
|
|
folders.len() as u64,
|
|
&[],
|
|
);
|
|
// A folder whose first pass has not run is not backed up yet, whatever its
|
|
// state column says (`docs/BUGS.md` B261).
|
|
let waiting = folders.iter().filter(|f| never_synced(f)).count();
|
|
let count = match waiting {
|
|
0 => count,
|
|
// Translators: {folders} is "N folders backed up"; {n} counts the folders whose first sync has not run yet.
|
|
n => ngettext_f(
|
|
"{folders} · {n} waiting for its first sync",
|
|
"{folders} · {n} waiting for their first sync",
|
|
n as u64,
|
|
&[("folders", &count)],
|
|
),
|
|
};
|
|
let attention = folders
|
|
.iter()
|
|
.filter(|f| f.state == "error" || f.state == "conflict")
|
|
.count();
|
|
match attention {
|
|
0 => count,
|
|
// Translators: {folders} is "N folders backed up"; {n} counts the folders with a problem.
|
|
n => ngettext_f(
|
|
"{folders} · {n} needs attention",
|
|
"{folders} · {n} need attention",
|
|
n as u64,
|
|
&[("folders", &count)],
|
|
),
|
|
}
|
|
}
|
|
|
|
/// Whether a synced folder is a mirror whose first pass has not finished.
|
|
/// Its `state` starts out `idle`, which would read as "up to date".
|
|
fn never_synced(folder: &SyncFolderInfo) -> bool {
|
|
folder.mode == "mirror" && folder.last_sync == 0 && folder.state == "idle"
|
|
}
|
|
|
|
/// Human label for a synced folder's `state` column. `never_synced` is a
|
|
/// mirror folder whose first pass has not finished: its `state` starts out
|
|
/// `idle`, and "up to date" would say the opposite of the truth (B261).
|
|
pub(crate) fn sync_state_label(state: &str, never_synced: bool) -> String {
|
|
match state {
|
|
"syncing" => gettext("syncing…"),
|
|
"error" => gettext("sync error"),
|
|
"conflict" => gettext("needs attention"),
|
|
_ if never_synced => gettext("waiting for first sync"),
|
|
_ => gettext("up to date"),
|
|
}
|
|
}
|
|
|
|
/// Human label for a sync pass in flight: what it is doing, to which file, and
|
|
/// how far along it is. Neither phase's total is exact — the scan's is an estimate
|
|
/// from the last pass, and the applying total grows as deeper paths are classified
|
|
/// — so both read "12 of 40" rather than a percentage that could go backwards.
|
|
pub(crate) fn sync_progress_label(p: &SyncProgress) -> String {
|
|
match p.phase {
|
|
SyncPhase::Scanning if p.total == 0 && p.done == 0 => gettext("checking for changes…"),
|
|
// Before the first pass finishes there is no estimate, so "12 of 12" would
|
|
// say nothing. The count alone still shows a first scan of a large folder
|
|
// moving, which can take many minutes before anything downloads.
|
|
// Translators: {n} counts the folders and files checked so far.
|
|
SyncPhase::Scanning if p.total == 0 => ngettext_f(
|
|
"checking for changes — {n} item checked",
|
|
"checking for changes — {n} items checked",
|
|
p.done as u64,
|
|
&[],
|
|
),
|
|
// Translators: {done} and {total} count folders and files checked so far.
|
|
SyncPhase::Scanning => gettext_f(
|
|
"checking for changes — {done} of {total}",
|
|
&[
|
|
("done", &p.done.to_string()),
|
|
("total", &p.total.max(p.done).to_string()),
|
|
],
|
|
),
|
|
SyncPhase::Applying => {
|
|
let done = (p.done + 1).to_string();
|
|
let total = p.total.max(p.done + 1).to_string();
|
|
if p.current.is_empty() {
|
|
// Translators: {done} and {total} count the changes applied so far.
|
|
gettext_f(
|
|
"syncing {done} of {total}",
|
|
&[("done", &done), ("total", &total)],
|
|
)
|
|
} else {
|
|
// Translators: {file} is the path being synced; {done} and {total} count the changes applied so far.
|
|
gettext_f(
|
|
"syncing {file} — {done} of {total}",
|
|
&[("file", &p.current), ("done", &done), ("total", &total)],
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Pick a local folder and hand it to the daemon to sync to this device.
|
|
pub(crate) fn prompt_add_sync_folder(ui: &Rc<Ui>) {
|
|
let win = ui_window(ui);
|
|
let dialog = gtk4::FileDialog::builder()
|
|
.title(gettext("Add Folder to Sync"))
|
|
.build();
|
|
let ui = ui.clone();
|
|
dialog.select_folder(win.as_ref(), gio::Cancellable::NONE, move |res| {
|
|
let Ok(folder) = res else { return };
|
|
let Some(local_path) = folder.path().and_then(|p| p.to_str().map(str::to_string)) else {
|
|
return;
|
|
};
|
|
let rx = spawn_request(
|
|
ui.dirs.control_socket(),
|
|
Request::AddSyncFolder {
|
|
local_path: local_path.clone(),
|
|
},
|
|
);
|
|
let ui = ui.clone();
|
|
glib::spawn_future_local(async move {
|
|
match rx.recv().await {
|
|
Ok(Ok(Response::Ok { .. })) => {
|
|
// The daemon acks before the row exists — registering the
|
|
// device and creating the remote folder is off-socket network
|
|
// work. A fixed delay here either fires too early (empty list)
|
|
// or too late (row flashes in). Instead let the periodic
|
|
// `refresh_locations` tick pick the row up whenever it
|
|
// actually lands, which is what keeps a running pass live too.
|
|
toast(&ui, &gettext("Syncing folder…"));
|
|
}
|
|
Ok(Ok(Response::Error { message, kind })) => {
|
|
toast_failure(&ui, &gettext("Couldn't add folder"), &message, kind)
|
|
}
|
|
_ => toast_error(
|
|
&ui,
|
|
&gettext("Couldn't add folder"),
|
|
&gettext("The Proton Drive service didn't respond."),
|
|
),
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
/// Ask the daemon what a device holds, then show a picker mapping each remote
|
|
/// folder onto a local directory. `device` is another computer as `(uid, name)`;
|
|
/// `None` is this machine's own device.
|
|
///
|
|
/// The daemon's paths are proposals — from the device's `profile.json` when it
|
|
/// makes sense here, else `~/<name>` — so every one of them is editable and
|
|
/// nothing is restored without being ticked.
|
|
pub(crate) fn prompt_restore_folders(ui: &Rc<Ui>, device: Option<(String, String)>) {
|
|
ui.busy_begin();
|
|
let request = match &device {
|
|
Some((uid, _)) => Request::ListDeviceRestorableFolders {
|
|
device: uid.clone(),
|
|
},
|
|
None => Request::ListRestorableFolders,
|
|
};
|
|
let rx = spawn_request(ui.dirs.control_socket(), request);
|
|
let ui = ui.clone();
|
|
glib::spawn_future_local(async move {
|
|
let result = rx.recv().await;
|
|
ui.busy_end();
|
|
match result {
|
|
Ok(Ok(Response::RestorableFolders { items })) => {
|
|
show_restore_picker(&ui, items, device)
|
|
}
|
|
Ok(Ok(Response::Error { message, kind })) => toast_failure(
|
|
&ui,
|
|
&gettext("Couldn't list folders to restore"),
|
|
&message,
|
|
kind,
|
|
),
|
|
_ => toast_error(
|
|
&ui,
|
|
&gettext("Couldn't list folders to restore"),
|
|
&gettext("The Proton Drive service didn't respond."),
|
|
),
|
|
}
|
|
});
|
|
}
|
|
|
|
/// The restore picker itself: one editable row per restorable folder.
|
|
fn show_restore_picker(
|
|
ui: &Rc<Ui>,
|
|
items: Vec<RestorableFolder>,
|
|
device: Option<(String, String)>,
|
|
) {
|
|
let win = ui_window(ui);
|
|
let candidates: Vec<RestorableFolder> =
|
|
items.into_iter().filter(|f| !f.already_synced).collect();
|
|
if candidates.is_empty() {
|
|
toast(
|
|
ui,
|
|
¬hing_to_restore(device.as_ref().map(|(_, n)| n.as_str())),
|
|
);
|
|
return;
|
|
}
|
|
|
|
let group = adw::PreferencesGroup::builder()
|
|
.description(gettext(
|
|
"Tick the folders to sync to this machine, and adjust where each one should live.",
|
|
))
|
|
.build();
|
|
// Held so the response handler can read back what the user ticked and typed.
|
|
let mut controls: Vec<(String, String, gtk4::CheckButton, adw::EntryRow)> = Vec::new();
|
|
for f in candidates {
|
|
let check = gtk4::CheckButton::builder()
|
|
.active(true)
|
|
.valign(gtk4::Align::Center)
|
|
.build();
|
|
let row = adw::EntryRow::builder()
|
|
.title(&f.name)
|
|
.use_markup(false)
|
|
.build();
|
|
row.set_text(&f.local_path);
|
|
row.add_prefix(&check);
|
|
group.add(&row);
|
|
controls.push((f.remote_uid, f.mode, check, row));
|
|
}
|
|
|
|
let scroll = gtk4::ScrolledWindow::builder()
|
|
.propagate_natural_height(true)
|
|
.max_content_height(420)
|
|
.child(&group)
|
|
.build();
|
|
let dialog = adw::AlertDialog::builder()
|
|
.heading(gettext("Restore Folders"))
|
|
.body(restore_picker_body(
|
|
device.as_ref().map(|(_, n)| n.as_str()),
|
|
))
|
|
.extra_child(&scroll)
|
|
.build();
|
|
dialog.add_response("cancel", &gettext("Cancel"));
|
|
dialog.add_response("restore", &gettext("Restore"));
|
|
dialog.set_response_appearance("restore", adw::ResponseAppearance::Suggested);
|
|
dialog.set_default_response(Some("restore"));
|
|
dialog.set_close_response("cancel");
|
|
|
|
let ui = ui.clone();
|
|
dialog.connect_response(None, move |_, resp| {
|
|
if resp != "restore" {
|
|
return;
|
|
}
|
|
let items: Vec<RestoreItem> = controls
|
|
.iter()
|
|
.filter(|(_, _, check, _)| check.is_active())
|
|
.map(|(uid, mode, _, row)| RestoreItem {
|
|
remote_uid: uid.clone(),
|
|
local_path: row.text().to_string(),
|
|
mode: mode.clone(),
|
|
})
|
|
.collect();
|
|
if items.is_empty() {
|
|
return;
|
|
}
|
|
// The daemon acks before the downloads finish, like AddSyncFolder — the
|
|
// rows appear as the periodic refresh picks them up.
|
|
run_devices_mutation(
|
|
&ui,
|
|
match &device {
|
|
Some((uid, _)) => Request::RestoreDeviceFolders {
|
|
device: uid.clone(),
|
|
items,
|
|
},
|
|
None => Request::RestoreSyncFolders { items },
|
|
},
|
|
&gettext("Restoring folders…"),
|
|
&gettext("Couldn't restore folders"),
|
|
);
|
|
});
|
|
dialog.present(win.as_ref());
|
|
}
|
|
|
|
/// The restore picker's body: whose backup the folders come from.
|
|
pub(crate) fn restore_picker_body(device: Option<&str>) -> String {
|
|
match device {
|
|
// Translators: {name} is the name of another computer.
|
|
Some(name) => gettext_f(
|
|
"These folders are backed up from “{name}”. Restored folders keep syncing with that computer's copy.",
|
|
&[("name", name)],
|
|
),
|
|
None => gettext("These folders are backed up under this computer in Proton Drive."),
|
|
}
|
|
}
|
|
|
|
/// The toast when every folder of a device is already synced here.
|
|
pub(crate) fn nothing_to_restore(device: Option<&str>) -> String {
|
|
match device {
|
|
// Translators: {name} is the name of another computer.
|
|
Some(name) => gettext_f(
|
|
"Nothing to restore — “{name}”'s folders are all synced here.",
|
|
&[("name", name)],
|
|
),
|
|
None => gettext("Nothing to restore — this computer's folders are all synced here."),
|
|
}
|
|
}
|
|
|
|
/// Flip a synced folder between `mirror` and `ondemand`. Reloads after so the
|
|
/// row's subtitle and switch reflect the daemon's real state (the request may be
|
|
/// rejected, e.g. switching to on-demand while a folder is mid-sync).
|
|
pub(crate) fn set_sync_folder_mode(ui: &Rc<Ui>, id: i64, mode: &'static str) {
|
|
let rx = spawn_request(
|
|
ui.dirs.control_socket(),
|
|
Request::SetSyncFolderMode {
|
|
id,
|
|
mode: mode.to_string(),
|
|
},
|
|
);
|
|
let ui = ui.clone();
|
|
glib::spawn_future_local(async move {
|
|
match rx.recv().await {
|
|
// The daemon's own text is written for the log; the toast says what
|
|
// the person will see happen. A switch may be queued behind a running
|
|
// pass, hence "will".
|
|
Ok(Ok(Response::Ok { .. })) => toast(
|
|
&ui,
|
|
&if mode == "ondemand" {
|
|
gettext("Folder will switch to online only")
|
|
} else {
|
|
gettext("Folder will download and stay synced")
|
|
},
|
|
),
|
|
Ok(Ok(Response::Error { message, kind })) => {
|
|
toast_failure(&ui, &gettext("Couldn't change mode"), &message, kind)
|
|
}
|
|
_ => toast_error(
|
|
&ui,
|
|
&gettext("Couldn't change mode"),
|
|
&gettext("The Proton Drive service didn't respond."),
|
|
),
|
|
}
|
|
reload_sync_pages(&ui);
|
|
});
|
|
}
|
|
|
|
/// Repaint whichever of the two pages that show sync folders is on screen. Sync
|
|
/// folder changes are raised from Locations as well as Computers, and both must
|
|
/// show the daemon's answer at once rather than on the next tick — a rejected
|
|
/// mode switch would otherwise stay visibly flipped.
|
|
pub(crate) fn reload_sync_pages(ui: &Rc<Ui>) {
|
|
match ui.stack.visible_child_name().as_deref() {
|
|
Some("devices") => load_devices(ui),
|
|
Some("locations") => refresh_locations(ui),
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
/// Confirm, then stop syncing a folder. Offers to also delete the cloud copy.
|
|
pub(crate) fn prompt_remove_sync_folder(
|
|
ui: &Rc<Ui>,
|
|
id: i64,
|
|
path: &str,
|
|
ondemand: bool,
|
|
attached: bool,
|
|
) {
|
|
let win = ui_window(ui);
|
|
// The two modes leave the user in opposite places, so they can't share a
|
|
// sentence. A mirror folder's files are already on this disk and stay there.
|
|
// An on-demand folder's are not: the path is a mount over content that lives
|
|
// in Proton Drive, so unmounting it leaves an empty directory — which is a
|
|
// nasty surprise if the dialog claimed the local files were safe, and is
|
|
// recoverable only by turning On-demand off *first* and letting it download.
|
|
let body = if attached {
|
|
gettext_f(
|
|
"Stop syncing “{path}”? Both the local files and the folder in My files are kept.",
|
|
&[("path", path)],
|
|
)
|
|
} else if ondemand {
|
|
// Translators: {path} is a local folder path.
|
|
gettext_f(
|
|
"Stop syncing “{path}”?\n\nThis folder is online only: its files live in Proton Drive, not on this disk, so the folder will be empty once it stops syncing. To keep a local copy, cancel, switch the folder to Synced, and wait for the download to finish before removing it.",
|
|
&[("path", path)],
|
|
)
|
|
} else {
|
|
// Translators: {path} is a local folder path.
|
|
gettext_f(
|
|
"Stop syncing “{path}”?\n\nThe local files stay on this disk and simply stop being synced. Choose whether to also delete the copy in Proton Drive.",
|
|
&[("path", path)],
|
|
)
|
|
};
|
|
let dialog = adw::AlertDialog::builder()
|
|
.heading(gettext("Stop Syncing Folder?"))
|
|
.body(body)
|
|
.build();
|
|
let group = adw::PreferencesGroup::new();
|
|
let delete_remote = adw::SwitchRow::builder()
|
|
.title(gettext("Also delete from Proton Drive"))
|
|
.subtitle(if ondemand {
|
|
gettext("Deletes the only copy of these files.")
|
|
} else {
|
|
gettext("The local copy is unaffected.")
|
|
})
|
|
.active(false)
|
|
.build();
|
|
group.add(&delete_remote);
|
|
if !attached {
|
|
dialog.set_extra_child(Some(&group));
|
|
}
|
|
dialog.add_response("cancel", &gettext("Cancel"));
|
|
dialog.add_response("remove", &gettext("Stop Syncing"));
|
|
dialog.set_response_appearance("remove", adw::ResponseAppearance::Destructive);
|
|
dialog.set_default_response(Some("cancel"));
|
|
dialog.set_close_response("cancel");
|
|
let ui = ui.clone();
|
|
dialog.connect_response(None, move |_, resp| {
|
|
if resp == "remove" {
|
|
run_devices_mutation(
|
|
&ui,
|
|
Request::RemoveSyncFolder {
|
|
id,
|
|
delete_remote: !attached && delete_remote.is_active(),
|
|
},
|
|
&gettext("Stopped syncing folder"),
|
|
&gettext("Couldn't stop syncing the folder"),
|
|
);
|
|
}
|
|
});
|
|
dialog.present(win.as_ref());
|
|
}
|
|
|
|
/// Prompt for a new device name and rename it.
|
|
pub(crate) fn prompt_rename_device(ui: &Rc<Ui>, uid: &str, current: &str) {
|
|
let win = ui_window(ui);
|
|
let dialog = adw::AlertDialog::builder()
|
|
.heading(gettext("Rename Computer"))
|
|
// Translators: {name} is the computer's current name.
|
|
.body(gettext_f("Rename “{name}”.", &[("name", current)]))
|
|
.build();
|
|
let group = adw::PreferencesGroup::new();
|
|
let row = adw::EntryRow::builder()
|
|
.title(gettext("New name"))
|
|
.activates_default(true)
|
|
.build();
|
|
row.set_text(current);
|
|
group.add(&row);
|
|
dialog.set_extra_child(Some(&group));
|
|
dialog.add_response("cancel", &gettext("Cancel"));
|
|
dialog.add_response("rename", &gettext("Rename"));
|
|
dialog.set_response_appearance("rename", adw::ResponseAppearance::Suggested);
|
|
dialog.set_default_response(Some("rename"));
|
|
dialog.set_close_response("cancel");
|
|
let ui = ui.clone();
|
|
let uid = uid.to_string();
|
|
dialog.connect_response(None, move |_, resp| {
|
|
if resp != "rename" {
|
|
return;
|
|
}
|
|
let name = row.text().trim().to_string();
|
|
if name.is_empty() {
|
|
toast_error(
|
|
&ui,
|
|
&gettext("Couldn't rename the computer"),
|
|
&gettext("A name is required."),
|
|
);
|
|
return;
|
|
}
|
|
run_devices_mutation(
|
|
&ui,
|
|
Request::RenameDevice {
|
|
uid: uid.clone(),
|
|
name,
|
|
},
|
|
&gettext("Computer renamed"),
|
|
&gettext("Couldn't rename the computer"),
|
|
);
|
|
});
|
|
dialog.present(win.as_ref());
|
|
}
|
|
|
|
/// Confirm, then remove (deregister) a computer. Removing deletes everything the
|
|
/// computer backed up, so the confirm button stays off until the name is typed.
|
|
pub(crate) fn prompt_remove_device(ui: &Rc<Ui>, uid: &str, name: &str) {
|
|
let win = ui_window(ui);
|
|
let confirm = adw::EntryRow::builder()
|
|
// Translators: {name} is the computer's name, which the user must type.
|
|
.title(gettext_f("Type “{name}” to confirm", &[("name", name)]))
|
|
.build();
|
|
let group = adw::PreferencesGroup::new();
|
|
group.add(&confirm);
|
|
let dialog = adw::AlertDialog::builder()
|
|
.heading(gettext("Remove Computer?"))
|
|
// Translators: {name} is the name of the computer being removed.
|
|
.body(gettext_f(
|
|
"Remove “{name}” from this account?\n\nEverything it backed up to Proton Drive is deleted along with it. The files on that computer itself are not touched — but this cannot be undone from here.",
|
|
&[("name", name)],
|
|
))
|
|
.extra_child(&group)
|
|
.build();
|
|
dialog.add_response("cancel", &gettext("Cancel"));
|
|
dialog.add_response("remove", &gettext("Remove"));
|
|
dialog.set_response_appearance("remove", adw::ResponseAppearance::Destructive);
|
|
dialog.set_response_enabled("remove", false);
|
|
dialog.set_default_response(Some("cancel"));
|
|
dialog.set_close_response("cancel");
|
|
let dialog_typed = dialog.clone();
|
|
let expected = name.to_string();
|
|
confirm.connect_changed(move |row| {
|
|
dialog_typed.set_response_enabled("remove", row.text().trim() == expected);
|
|
});
|
|
let ui = ui.clone();
|
|
let uid = uid.to_string();
|
|
dialog.connect_response(None, move |_, resp| {
|
|
if resp == "remove" {
|
|
run_devices_mutation(
|
|
&ui,
|
|
Request::DeleteDevice { uid: uid.clone() },
|
|
&gettext("Computer removed"),
|
|
&gettext("Couldn't remove the computer"),
|
|
);
|
|
}
|
|
});
|
|
dialog.present(win.as_ref());
|
|
}
|
|
|
|
/// Confirm, then continue another computer's backup on this machine (adopt its
|
|
/// device).
|
|
///
|
|
/// Worth a confirmation rather than a plain click: adoption re-points this
|
|
/// machine's syncing at another computer's device folder, and the folders
|
|
/// already synced here keep pointing at the old one until they are removed. The
|
|
/// dialog says so, because the alternative is a user discovering it by watching
|
|
/// their folders diverge.
|
|
pub(crate) fn prompt_adopt_device(ui: &Rc<Ui>, uid: &str, name: &str) {
|
|
let win = ui_window(ui);
|
|
let dialog = adw::AlertDialog::builder()
|
|
.heading(gettext("Continue This Backup Here?"))
|
|
// Translators: {name} is the name of the other computer whose backup this one takes over.
|
|
.body(gettext_f(
|
|
"This computer takes over the backup of “{name}”, for example after a reinstall.\n\nNew synced folders go under “{name}” in Proton Drive, even if this computer's name changes. Folders already synced here are not moved. Use “Restore to This Computer” afterwards to bring back what “{name}” was syncing.",
|
|
&[("name", name)],
|
|
))
|
|
.build();
|
|
dialog.add_response("cancel", &gettext("Cancel"));
|
|
dialog.add_response("adopt", &gettext("Continue Here"));
|
|
dialog.set_response_appearance("adopt", adw::ResponseAppearance::Suggested);
|
|
dialog.set_default_response(Some("cancel"));
|
|
dialog.set_close_response("cancel");
|
|
let ui = ui.clone();
|
|
let uid = uid.to_string();
|
|
// Translators: {name} is the name of the computer whose backup this one took over.
|
|
let done = gettext_f("Now backing up as “{name}”", &[("name", name)]);
|
|
dialog.connect_response(None, move |_, resp| {
|
|
if resp == "adopt" {
|
|
run_devices_mutation(
|
|
&ui,
|
|
Request::AdoptDevice {
|
|
uid: Some(uid.clone()),
|
|
},
|
|
&done,
|
|
&gettext("Couldn't continue that backup here"),
|
|
);
|
|
}
|
|
});
|
|
dialog.present(win.as_ref());
|
|
}
|
|
|
|
/// Ask before syncing into another computer's device alongside it, then offer
|
|
/// its folders for syncing here.
|
|
///
|
|
/// The same adoption as "Continue This Backup Here", but the other computer
|
|
/// goes on syncing, so the dialog says what that means: the two keep the same
|
|
/// folders in step, deletions included.
|
|
pub(crate) fn prompt_join_device(ui: &Rc<Ui>, uid: &str, name: &str) {
|
|
let win = ui_window(ui);
|
|
let dialog = adw::AlertDialog::builder()
|
|
.heading(gettext("Sync With This Computer?"))
|
|
// Translators: {name} is the name of the other computer this one syncs with.
|
|
.body(gettext_f(
|
|
"This computer and “{name}” keep the same folders in step. A change or a deletion on one reaches the other.\n\nNew synced folders on this computer go under “{name}” in Proton Drive. Folders already synced here stay where they are. Next you choose which of its folders to sync here.",
|
|
&[("name", name)],
|
|
))
|
|
.build();
|
|
dialog.add_response("cancel", &gettext("Cancel"));
|
|
dialog.add_response("join", &gettext("Sync Here"));
|
|
dialog.set_response_appearance("join", adw::ResponseAppearance::Suggested);
|
|
dialog.set_default_response(Some("cancel"));
|
|
dialog.set_close_response("cancel");
|
|
let ui = ui.clone();
|
|
let uid = uid.to_string();
|
|
// Translators: {name} is the name of the other computer this one now syncs with.
|
|
let done = gettext_f("Now syncing with “{name}”", &[("name", name)]);
|
|
dialog.connect_response(None, move |_, resp| {
|
|
if resp != "join" {
|
|
return;
|
|
}
|
|
ui.busy_begin();
|
|
let rx = spawn_request(
|
|
ui.dirs.control_socket(),
|
|
Request::AdoptDevice {
|
|
uid: Some(uid.clone()),
|
|
},
|
|
);
|
|
let (ui, done) = (ui.clone(), done.clone());
|
|
glib::spawn_future_local(async move {
|
|
let result = rx.recv().await;
|
|
ui.busy_end();
|
|
let failed = gettext("Couldn't sync with that computer");
|
|
match result {
|
|
Ok(Ok(Response::Ok { .. })) => {
|
|
reload_sync_pages(&ui);
|
|
toast(&ui, &done);
|
|
// The device is this computer's now, so its own restore
|
|
// picker offers the folders.
|
|
prompt_restore_folders(&ui, None);
|
|
}
|
|
Ok(Ok(Response::Error { message, kind })) => {
|
|
toast_failure(&ui, &failed, &message, kind)
|
|
}
|
|
_ => toast_error(
|
|
&ui,
|
|
&failed,
|
|
&gettext("The Proton Drive service didn't respond."),
|
|
),
|
|
}
|
|
});
|
|
});
|
|
dialog.present(win.as_ref());
|
|
}
|
|
|
|
/// Ask before moving another computer's folders into this computer's backup,
|
|
/// then offer them for syncing here.
|
|
///
|
|
/// Destructive-looking on purpose: the other computer keeps its device but
|
|
/// loses its folders, and a copy of Proton Drive still running there would
|
|
/// watch them vanish.
|
|
pub(crate) fn prompt_migrate_device(ui: &Rc<Ui>, uid: &str, name: &str) {
|
|
let win = ui_window(ui);
|
|
let dialog = adw::AlertDialog::builder()
|
|
.heading(gettext("Move Backup to This Computer?"))
|
|
// Translators: {name} is the name of the other computer whose folders move to this one.
|
|
.body(gettext_f(
|
|
"The folders backed up by “{name}” move into this computer's backup in Proton Drive, and you choose where they go on this computer. “{name}” stays in your account, without those folders.\n\nStop Proton Drive on “{name}” first. Otherwise it sees its folders disappear.",
|
|
&[("name", name)],
|
|
))
|
|
.build();
|
|
dialog.add_response("cancel", &gettext("Cancel"));
|
|
dialog.add_response("move", &gettext("Move Here"));
|
|
dialog.set_response_appearance("move", adw::ResponseAppearance::Destructive);
|
|
dialog.set_default_response(Some("cancel"));
|
|
dialog.set_close_response("cancel");
|
|
let ui = ui.clone();
|
|
let uid = uid.to_string();
|
|
// Translators: {name} is the name of the computer whose folders moved to this one.
|
|
let done = gettext_f("Moved the backup of “{name}”", &[("name", name)]);
|
|
dialog.connect_response(None, move |_, resp| {
|
|
if resp != "move" {
|
|
return;
|
|
}
|
|
ui.busy_begin();
|
|
let rx = spawn_request(
|
|
ui.dirs.control_socket(),
|
|
Request::MigrateDevice { uid: uid.clone() },
|
|
);
|
|
let (ui, done) = (ui.clone(), done.clone());
|
|
glib::spawn_future_local(async move {
|
|
let result = rx.recv().await;
|
|
ui.busy_end();
|
|
let failed = gettext("Couldn't move that backup");
|
|
match result {
|
|
Ok(Ok(Response::Ok { .. })) => {
|
|
reload_sync_pages(&ui);
|
|
toast(&ui, &done);
|
|
// The folders are this computer's now, so its own restore
|
|
// picker is where the user chooses their local paths.
|
|
prompt_restore_folders(&ui, None);
|
|
}
|
|
Ok(Ok(Response::Error { message, kind })) => {
|
|
toast_failure(&ui, &failed, &message, kind)
|
|
}
|
|
_ => toast_error(
|
|
&ui,
|
|
&failed,
|
|
&gettext("The Proton Drive service didn't respond."),
|
|
),
|
|
}
|
|
});
|
|
});
|
|
dialog.present(win.as_ref());
|
|
}
|
|
|
|
/// Run a mutation raised from Computers or Locations and reload the page on success.
|
|
pub(crate) fn run_devices_mutation(ui: &Rc<Ui>, req: Request, done: &str, failed: &str) {
|
|
ui.busy_begin();
|
|
let rx = spawn_request(ui.dirs.control_socket(), req);
|
|
let ui = ui.clone();
|
|
let done = done.to_string();
|
|
let failed = failed.to_string();
|
|
glib::spawn_future_local(async move {
|
|
let result = rx.recv().await;
|
|
ui.busy_end();
|
|
match result {
|
|
Ok(Ok(Response::Ok { .. })) => {
|
|
reload_sync_pages(&ui);
|
|
toast(&ui, &done);
|
|
}
|
|
Ok(Ok(Response::Error { message, kind })) => {
|
|
toast_failure(&ui, &failed, &message, kind)
|
|
}
|
|
_ => toast_error(
|
|
&ui,
|
|
&failed,
|
|
&gettext("The Proton Drive service didn't respond."),
|
|
),
|
|
}
|
|
});
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
fn folder(state: &str) -> SyncFolderInfo {
|
|
SyncFolderInfo {
|
|
kind: "device".into(),
|
|
id: 1,
|
|
local_path: "/home/u/Documents".into(),
|
|
remote_uid: "vol~link".into(),
|
|
mode: "mirror".into(),
|
|
state: state.into(),
|
|
last_sync: 1_700_000_000,
|
|
pending_mode: None,
|
|
progress: None,
|
|
paused: false,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn attached_my_files_folders_do_not_count_as_device_backups() {
|
|
let mut attached = folder("error");
|
|
attached.kind = "attached".into();
|
|
assert_eq!(
|
|
this_computer_subtitle(&[attached]),
|
|
"No folders backed up yet"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_machine_with_no_folders_says_so() {
|
|
assert_eq!(this_computer_subtitle(&[]), "No folders backed up yet");
|
|
}
|
|
|
|
/// A folder added a moment ago is not backed up yet, and the row must not
|
|
/// say it is (`docs/BUGS.md` B261). An on-demand folder has no first sync.
|
|
#[test]
|
|
fn a_folder_before_its_first_sync_is_not_counted_as_backed_up() {
|
|
let new = SyncFolderInfo {
|
|
last_sync: 0,
|
|
..folder("idle")
|
|
};
|
|
assert_eq!(
|
|
this_computer_subtitle(&[folder("idle"), new.clone()]),
|
|
"2 folders backed up · 1 waiting for its first sync"
|
|
);
|
|
let failed = SyncFolderInfo {
|
|
state: "error".into(),
|
|
..new.clone()
|
|
};
|
|
assert_eq!(
|
|
this_computer_subtitle(&[new.clone(), failed]),
|
|
"2 folders backed up · 1 waiting for its first sync · 1 needs attention"
|
|
);
|
|
let on_demand = SyncFolderInfo {
|
|
mode: "ondemand".into(),
|
|
..new
|
|
};
|
|
assert_eq!(this_computer_subtitle(&[on_demand]), "1 folder backed up");
|
|
}
|
|
|
|
#[test]
|
|
fn folders_needing_attention_are_counted_not_hidden() {
|
|
// The per-folder rows live on the Sync page, so this row is the only
|
|
// place the Computers page can surface that something is wrong.
|
|
assert_eq!(
|
|
this_computer_subtitle(&[folder("idle"), folder("idle")]),
|
|
"2 folders backed up"
|
|
);
|
|
assert_eq!(
|
|
this_computer_subtitle(&[folder("idle"), folder("error")]),
|
|
"2 folders backed up · 1 needs attention"
|
|
);
|
|
assert_eq!(
|
|
this_computer_subtitle(&[folder("conflict"), folder("error")]),
|
|
"2 folders backed up · 2 need attention"
|
|
);
|
|
}
|
|
|
|
fn scanning(done: usize, total: usize) -> SyncProgress {
|
|
SyncProgress {
|
|
phase: SyncPhase::Scanning,
|
|
done,
|
|
total,
|
|
current: String::new(),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_first_scan_counts_what_it_checked() {
|
|
// A first sync of a large folder scans for many minutes before anything
|
|
// downloads; without a count it reads as stuck (#46).
|
|
assert_eq!(
|
|
sync_progress_label(&scanning(0, 0)),
|
|
"checking for changes…"
|
|
);
|
|
assert_eq!(
|
|
sync_progress_label(&scanning(1, 0)),
|
|
"checking for changes — 1 item checked"
|
|
);
|
|
assert_eq!(
|
|
sync_progress_label(&scanning(1234, 0)),
|
|
"checking for changes — 1234 items checked"
|
|
);
|
|
assert_eq!(
|
|
sync_progress_label(&scanning(12, 40)),
|
|
"checking for changes — 12 of 40"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_restore_picker_names_the_computer_it_restores_from() {
|
|
assert!(restore_picker_body(Some("laptop")).contains("“laptop”"));
|
|
assert!(restore_picker_body(None).contains("this computer"));
|
|
assert!(nothing_to_restore(Some("laptop")).contains("“laptop”"));
|
|
}
|
|
|
|
fn device(device_type: &str, last_sync: Option<i64>) -> DeviceInfo {
|
|
DeviceInfo {
|
|
uid: "dev".into(),
|
|
name: "laptop".into(),
|
|
device_type: device_type.into(),
|
|
last_sync,
|
|
this_device: false,
|
|
adopted: false,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_computer_that_never_backed_up_says_no_backups_yet() {
|
|
assert_eq!(
|
|
device_subtitle(&device("Linux", None)),
|
|
"Linux · no backups yet"
|
|
);
|
|
assert_eq!(
|
|
device_subtitle(&device("Linux", Some(0))),
|
|
"Linux · no backups yet"
|
|
);
|
|
assert!(device_subtitle(&device("MacOs", Some(1))).starts_with("macOS · last backup "));
|
|
}
|
|
}
|