mirror of
https://github.com/narrrl/proton-drive-linux.git
synced 2026-11-21 18:23:48 +01:00
Compare commits
18
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
2bf1622793 | ||
|
|
2ea189f1d9 | ||
|
|
8af671d8ed | ||
|
|
9047bdd741 | ||
|
|
ca20e5ed22 | ||
|
|
10bc9a6a37 | ||
|
|
890adbc189 | ||
|
|
960c6afe2d | ||
|
|
1b545ba369 | ||
|
|
b854c1e819 | ||
|
|
3fbe651f94 | ||
|
|
61b992cb48 | ||
|
|
08e0e80f34 | ||
|
|
0488ccd5f6 | ||
|
|
62d16e03cf | ||
|
|
c92f78b5c8 | ||
|
|
b034e1d4e3 | ||
|
|
43b76d4791 |
No files matched your search
Generated
+7
-8
@@ -3934,8 +3934,6 @@ dependencies = [
|
||||
"dbus-secret-service",
|
||||
"dbus-secret-service-keyring-store",
|
||||
"keyring-core",
|
||||
"proton-sdk",
|
||||
"serde_json",
|
||||
"thiserror 2.0.21",
|
||||
"tracing",
|
||||
"windows-native-keyring-store",
|
||||
@@ -3954,9 +3952,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "proton-drive-rs"
|
||||
version = "0.12.1"
|
||||
version = "0.12.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d05ad4be849ce2104759631063dd06867fbe6b6f0e5c37a172a84b5a90203fa7"
|
||||
checksum = "e9f7e67c864033e2d13ff48f9e0738f22ae6401cc47131b266b90c23e0dcc381"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"base64 0.23.1",
|
||||
@@ -4024,15 +4022,16 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "proton-gallery-rs"
|
||||
version = "0.1.1"
|
||||
version = "0.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "dc9c9bbb76a5fba4071ee90de4aada71c292c0e408024ddfb04a12869291404a"
|
||||
checksum = "e374d2053de5df0e6b0797df65d0d024dbce35f7aedfefd4a656896a0495dc9b"
|
||||
dependencies = [
|
||||
"aes-gcm 0.11.1",
|
||||
"async-trait",
|
||||
"getrandom 0.4.3",
|
||||
"hex",
|
||||
"kamadak-exif",
|
||||
"proton-base-rs",
|
||||
"rusqlite",
|
||||
"serde",
|
||||
"serde_json",
|
||||
@@ -4061,9 +4060,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "proton-sdk"
|
||||
version = "0.12.1"
|
||||
version = "0.12.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "80c381e9066c0bca3c32597df2e902eecaa4c6e05e202e70ec9d0ac2eec78bfe"
|
||||
checksum = "a443d600225687a92724b455c025a049b8668fe9da52fbf7cb46583a8e4970a7"
|
||||
dependencies = [
|
||||
"aes-gcm 0.11.1",
|
||||
"async-trait",
|
||||
|
||||
+3
-3
@@ -15,10 +15,10 @@ keywords = ["proton", "drive", "fuse", "sync", "linux"]
|
||||
categories = ["filesystem", "command-line-utilities"]
|
||||
|
||||
[workspace.dependencies]
|
||||
proton-sdk = { version = "0.12.1" }
|
||||
proton-drive-rs = { version = "0.12.1" }
|
||||
proton-sdk = { version = "0.12.3" }
|
||||
proton-drive-rs = { version = "0.12.3" }
|
||||
proton-gallery-app-rs = "0.1.0"
|
||||
proton-gallery-rs = "0.1.1"
|
||||
proton-gallery-rs = "0.1.5"
|
||||
chrono = { version = "0.4", default-features = false, features = ["std"] }
|
||||
|
||||
# Internal crates.
|
||||
|
||||
@@ -25,7 +25,7 @@ shell-words.workspace = true
|
||||
sha2.workspace = true
|
||||
rusqlite.workspace = true
|
||||
keyring-core.workspace = true
|
||||
proton-auth-rs = { workspace = true, features = ["keyring", "session"] }
|
||||
proton-auth-rs = { workspace = true, features = ["keyring"] }
|
||||
proton-base-rs.workspace = true
|
||||
dbus-secret-service-keyring-store.workspace = true
|
||||
dbus-secret-service.workspace = true
|
||||
|
||||
@@ -28,7 +28,6 @@ use std::time::Duration;
|
||||
use base64::Engine as _;
|
||||
use base64::engine::general_purpose::STANDARD as BASE64;
|
||||
use keyring_core::Entry;
|
||||
use proton_auth_rs::session::{self, SignInError, Step};
|
||||
use proton_auth_rs::{KeyringStore, SecretStore};
|
||||
use proton_drive_rs::{KeySalt, ProtonDriveClient};
|
||||
use proton_sdk::account::KeyPassphrases;
|
||||
@@ -37,6 +36,7 @@ use proton_sdk::cache::EncryptedCacheRepository;
|
||||
use proton_sdk::config::ProtonClientConfiguration;
|
||||
use proton_sdk::error::ProtonError;
|
||||
use proton_sdk::http::Tokens;
|
||||
use proton_sdk::login::{self, LoginError, Step};
|
||||
use proton_sdk::session::{PasswordMode, ProtonApiSession, ResumeParameters};
|
||||
use proton_sdk::telemetry::TracingTelemetry;
|
||||
use serde::{Deserialize, Serialize};
|
||||
@@ -280,12 +280,12 @@ pub async fn login_verified(
|
||||
get_totp: impl Fn() -> Result<String>,
|
||||
get_mailbox: impl Fn(u32) -> Result<Mailbox>,
|
||||
) -> Result<()> {
|
||||
// The sequence is `proton_auth_rs::session`, shared with the other Proton
|
||||
// The sequence is `proton_sdk::login`, shared with the other Proton
|
||||
// apps. It reads the key salts before unlocking, while this access token
|
||||
// still has the `locked` scope: after its first refresh it never will
|
||||
// again, and without them no later resume can unlock the key chain. See
|
||||
// `StoredSession::key_salts`.
|
||||
let mut step = session::begin(client_config(), username, password, verification)
|
||||
let mut step = login::begin(client_config(), username, password, verification)
|
||||
.await
|
||||
.map_err(sign_in_error)?;
|
||||
let (unlocked, remember) = loop {
|
||||
@@ -305,9 +305,7 @@ pub async fn login_verified(
|
||||
let mailbox = get_mailbox(attempt)?;
|
||||
match pending.mailbox_password(&mailbox.password).await {
|
||||
Ok(unlocked) => break (unlocked, mailbox.remember),
|
||||
Err(SignInError::WrongMailboxPassword)
|
||||
if attempt + 1 < MAILBOX_ATTEMPTS =>
|
||||
{
|
||||
Err(LoginError::WrongMailboxPassword) if attempt + 1 < MAILBOX_ATTEMPTS => {
|
||||
attempt += 1;
|
||||
}
|
||||
Err(e) => return Err(sign_in_error(e)),
|
||||
@@ -317,16 +315,16 @@ pub async fn login_verified(
|
||||
};
|
||||
};
|
||||
|
||||
let tokens = unlocked.tokens().await;
|
||||
let tokens = unlocked.resume_parameters().await;
|
||||
register_refresh_handler(&unlocked.session, tokens.refresh_token.clone());
|
||||
let stored = StoredSession {
|
||||
session_id: tokens.session_id,
|
||||
session_id: tokens.session_id.as_str().to_owned(),
|
||||
username: tokens.username,
|
||||
user_id: tokens.user_id,
|
||||
user_id: tokens.user_id.as_str().to_owned(),
|
||||
access_token: tokens.access_token,
|
||||
refresh_token: tokens.refresh_token,
|
||||
scopes: tokens.scopes,
|
||||
password_mode: session::password_mode_to_wire(tokens.password_mode),
|
||||
password_mode: tokens.password_mode.to_wire() as u8,
|
||||
mailbox_password: String::new(),
|
||||
key_salts: unlocked.key_salts,
|
||||
key_passphrases: None,
|
||||
@@ -412,15 +410,15 @@ fn decode_secret(secret: &[u8]) -> Option<KeyPassphrases> {
|
||||
/// names a solvable method is a [`Error::HumanVerificationRequired`]: one that
|
||||
/// offers only `email`/`sms` stays a plain API error, because sending the UI to
|
||||
/// open a page it cannot complete reads as a hang rather than a refusal.
|
||||
fn sign_in_error(e: SignInError) -> Error {
|
||||
fn sign_in_error(e: LoginError) -> Error {
|
||||
match e {
|
||||
SignInError::HumanVerification(hv) => Error::HumanVerificationRequired(hv),
|
||||
SignInError::SecurityKeyOnly => Error::SecurityKeyOnly,
|
||||
SignInError::Blocked(api) | SignInError::Rejected(api) | SignInError::WrongCode(api) => {
|
||||
LoginError::HumanVerification(hv) => Error::HumanVerificationRequired(hv),
|
||||
LoginError::SecurityKeyOnly => Error::SecurityKeyOnly,
|
||||
LoginError::Blocked(api) | LoginError::Rejected(api) | LoginError::WrongCode(api) => {
|
||||
Error::Proton(ProtonError::Api(api))
|
||||
}
|
||||
SignInError::WrongMailboxPassword => Error::WrongMailboxPassword,
|
||||
SignInError::Proton(e) => e.into(),
|
||||
LoginError::WrongMailboxPassword => Error::WrongMailboxPassword,
|
||||
LoginError::Proton(e) => e.into(),
|
||||
other => Error::Other(other.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -154,7 +154,6 @@ fn follow_changes(ui: &Rc<Ui>, state: &FeedState, topics: &[Topic]) {
|
||||
ui.gallery.decode_queue.borrow_mut().clear();
|
||||
ui.gallery.thumb_wanted.borrow_mut().clear();
|
||||
ui.gallery.photo_tex.borrow_mut().clear();
|
||||
ui.gallery.photo_tex_order.borrow_mut().clear();
|
||||
ui.gallery.model.remove_all();
|
||||
ui.gallery.groups.remove_all();
|
||||
ui.gallery.row_by_photo.borrow_mut().clear();
|
||||
|
||||
@@ -0,0 +1,248 @@
|
||||
//! A least-recently-used cache with a cost budget.
|
||||
//!
|
||||
//! Each entry carries a cost (bytes for a texture cache, `1` for a cache capped
|
||||
//! by count). Inserting past the budget drops the entries used longest ago.
|
||||
//! Lookups and touches are logarithmic, so a cache of a few thousand textures
|
||||
//! can be touched on every tile bind without a linear scan.
|
||||
|
||||
use std::borrow::Borrow;
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
use std::hash::Hash;
|
||||
|
||||
struct Entry<V> {
|
||||
value: V,
|
||||
cost: usize,
|
||||
stamp: u64,
|
||||
}
|
||||
|
||||
pub(crate) struct Lru<K, V> {
|
||||
entries: HashMap<K, Entry<V>>,
|
||||
/// Entries by the stamp of their last use, oldest first.
|
||||
order: BTreeMap<u64, K>,
|
||||
next: u64,
|
||||
used: usize,
|
||||
budget: usize,
|
||||
}
|
||||
|
||||
impl<K: Eq + Hash + Clone, V> Lru<K, V> {
|
||||
pub(crate) fn new(budget: usize) -> Self {
|
||||
Self {
|
||||
entries: HashMap::new(),
|
||||
order: BTreeMap::new(),
|
||||
next: 0,
|
||||
used: 0,
|
||||
budget,
|
||||
}
|
||||
}
|
||||
|
||||
/// Look an entry up without marking it used.
|
||||
pub(crate) fn get<Q>(&self, key: &Q) -> Option<&V>
|
||||
where
|
||||
K: Borrow<Q>,
|
||||
Q: Eq + Hash + ?Sized,
|
||||
{
|
||||
self.entries.get(key).map(|entry| &entry.value)
|
||||
}
|
||||
|
||||
pub(crate) fn contains_key<Q>(&self, key: &Q) -> bool
|
||||
where
|
||||
K: Borrow<Q>,
|
||||
Q: Eq + Hash + ?Sized,
|
||||
{
|
||||
self.entries.contains_key(key)
|
||||
}
|
||||
|
||||
/// Mark an entry as just used, so it is the last to be evicted. Returns
|
||||
/// whether it was there.
|
||||
pub(crate) fn touch<Q>(&mut self, key: &Q) -> bool
|
||||
where
|
||||
K: Borrow<Q>,
|
||||
Q: Eq + Hash + ?Sized,
|
||||
{
|
||||
let stamp = self.next;
|
||||
let Some(entry) = self.entries.get_mut(key) else {
|
||||
return false;
|
||||
};
|
||||
if let Some(held) = self.order.remove(&entry.stamp) {
|
||||
self.order.insert(stamp, held);
|
||||
}
|
||||
entry.stamp = stamp;
|
||||
self.next += 1;
|
||||
true
|
||||
}
|
||||
|
||||
/// Look an entry up and mark it used.
|
||||
pub(crate) fn fetch<Q>(&mut self, key: &Q) -> Option<&V>
|
||||
where
|
||||
K: Borrow<Q>,
|
||||
Q: Eq + Hash + ?Sized,
|
||||
{
|
||||
if !self.touch(key) {
|
||||
return None;
|
||||
}
|
||||
self.get(key)
|
||||
}
|
||||
|
||||
/// Store `value` as the most recently used entry, then evict the least
|
||||
/// recently used ones until the total cost fits the budget again. The new
|
||||
/// entry itself is never evicted, even when it alone is over budget.
|
||||
pub(crate) fn insert(&mut self, key: K, value: V, cost: usize) {
|
||||
self.remove(&key);
|
||||
let stamp = self.next;
|
||||
self.next += 1;
|
||||
self.order.insert(stamp, key.clone());
|
||||
self.entries.insert(key, Entry { value, cost, stamp });
|
||||
self.used += cost;
|
||||
while self.used > self.budget && self.order.len() > 1 {
|
||||
let Some((_, oldest)) = self.order.pop_first() else {
|
||||
break;
|
||||
};
|
||||
if let Some(entry) = self.entries.remove(&oldest) {
|
||||
self.used -= entry.cost;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn remove<Q>(&mut self, key: &Q) -> Option<V>
|
||||
where
|
||||
K: Borrow<Q>,
|
||||
Q: Eq + Hash + ?Sized,
|
||||
{
|
||||
let entry = self.entries.remove(key)?;
|
||||
self.order.remove(&entry.stamp);
|
||||
self.used -= entry.cost;
|
||||
Some(entry.value)
|
||||
}
|
||||
|
||||
/// Keep only the entries `keep` accepts.
|
||||
pub(crate) fn retain(&mut self, mut keep: impl FnMut(&K, &V) -> bool) {
|
||||
let order = &mut self.order;
|
||||
let used = &mut self.used;
|
||||
self.entries.retain(|key, entry| {
|
||||
let kept = keep(key, &entry.value);
|
||||
if !kept {
|
||||
order.remove(&entry.stamp);
|
||||
*used -= entry.cost;
|
||||
}
|
||||
kept
|
||||
});
|
||||
}
|
||||
|
||||
pub(crate) fn clear(&mut self) {
|
||||
self.entries.clear();
|
||||
self.order.clear();
|
||||
self.used = 0;
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(crate) fn len(&self) -> usize {
|
||||
self.entries.len()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(crate) fn used(&self) -> usize {
|
||||
self.used
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::Lru;
|
||||
|
||||
#[test]
|
||||
fn evicts_least_recently_used_past_budget() {
|
||||
let mut cache = Lru::new(3);
|
||||
cache.insert("a", 1, 1);
|
||||
cache.insert("b", 2, 1);
|
||||
cache.insert("c", 3, 1);
|
||||
assert!(cache.touch("a"));
|
||||
cache.insert("d", 4, 1);
|
||||
assert!(cache.contains_key("a"));
|
||||
assert!(!cache.contains_key("b"));
|
||||
assert!(cache.contains_key("c"));
|
||||
assert!(cache.contains_key("d"));
|
||||
assert_eq!(cache.len(), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn budget_counts_cost_not_entries() {
|
||||
let mut cache = Lru::new(100);
|
||||
cache.insert("small", (), 10);
|
||||
cache.insert("medium", (), 40);
|
||||
cache.insert("large", (), 60);
|
||||
// 110 > 100: the oldest goes, and that is enough.
|
||||
assert!(!cache.contains_key("small"));
|
||||
assert_eq!(cache.used(), 100);
|
||||
cache.insert("huge", (), 90);
|
||||
assert_eq!(cache.used(), 90);
|
||||
assert_eq!(cache.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn keeps_a_single_entry_over_budget() {
|
||||
let mut cache = Lru::new(10);
|
||||
cache.insert("a", (), 5);
|
||||
cache.insert("big", (), 50);
|
||||
assert!(cache.contains_key("big"));
|
||||
assert!(!cache.contains_key("a"));
|
||||
assert_eq!(cache.used(), 50);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn remove_and_clear_keep_cost_in_step() {
|
||||
let mut cache = Lru::new(100);
|
||||
cache.insert("a", (), 10);
|
||||
cache.insert("b", (), 20);
|
||||
assert_eq!(cache.remove("a"), Some(()));
|
||||
assert_eq!(cache.used(), 20);
|
||||
cache.clear();
|
||||
assert_eq!(cache.used(), 0);
|
||||
assert_eq!(cache.len(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reinsert_replaces_cost_and_refreshes() {
|
||||
let mut cache = Lru::new(30);
|
||||
cache.insert("a", 1, 10);
|
||||
cache.insert("b", 2, 10);
|
||||
cache.insert("a", 3, 15);
|
||||
assert_eq!(cache.used(), 25);
|
||||
assert_eq!(cache.get("a"), Some(&3));
|
||||
cache.insert("c", 4, 10);
|
||||
// "b" was used longest ago now.
|
||||
assert!(!cache.contains_key("b"));
|
||||
assert!(cache.contains_key("a"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fetch_touches_and_get_does_not() {
|
||||
let mut cache = Lru::new(2);
|
||||
cache.insert("a", 1, 1);
|
||||
cache.insert("b", 2, 1);
|
||||
assert_eq!(cache.get("a"), Some(&1));
|
||||
cache.insert("c", 3, 1);
|
||||
assert!(!cache.contains_key("a"));
|
||||
assert_eq!(cache.fetch("b"), Some(&2));
|
||||
cache.insert("d", 4, 1);
|
||||
assert!(cache.contains_key("b"));
|
||||
assert!(!cache.contains_key("c"));
|
||||
assert_eq!(cache.fetch("missing"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn retain_drops_rejected_entries_and_their_cost() {
|
||||
let mut cache = Lru::new(100);
|
||||
cache.insert((true, "a".to_string()), (), 10);
|
||||
cache.insert((false, "b".to_string()), (), 20);
|
||||
cache.insert((true, "c".to_string()), (), 30);
|
||||
cache.retain(|(private, _), _| !private);
|
||||
assert_eq!(cache.used(), 20);
|
||||
assert_eq!(cache.len(), 1);
|
||||
assert!(cache.remove(&(false, "b".to_string())).is_some());
|
||||
assert_eq!(cache.used(), 0);
|
||||
cache.insert((true, "d".to_string()), (), 10);
|
||||
cache.clear();
|
||||
assert_eq!(cache.used(), 0);
|
||||
assert_eq!(cache.len(), 0);
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,7 @@ pub(crate) mod dates;
|
||||
pub(crate) mod events;
|
||||
#[path = "../i18n.rs"]
|
||||
pub(crate) mod i18n;
|
||||
pub(crate) mod lru;
|
||||
pub(crate) mod pages;
|
||||
pub(crate) mod reload;
|
||||
#[path = "../theme.rs"]
|
||||
@@ -15,6 +16,7 @@ pub(crate) mod widgets;
|
||||
|
||||
use compat::*;
|
||||
use events::*;
|
||||
use lru::Lru;
|
||||
use pages::activity::*;
|
||||
use pages::albums::*;
|
||||
use pages::browser::*;
|
||||
@@ -190,16 +192,11 @@ impl Ui {
|
||||
/// Scrolling back over a day then repaints from memory rather than decoding
|
||||
/// the same JPEGs off disk again.
|
||||
fn store_texture(&self, uid: &str, texture: gtk4::gdk::Texture) {
|
||||
let mut cache = self.gallery.photo_tex.borrow_mut();
|
||||
let mut order = self.gallery.photo_tex_order.borrow_mut();
|
||||
if cache.insert(uid.to_string(), texture).is_none() {
|
||||
order.push_back(uid.to_string());
|
||||
}
|
||||
while order.len() > TEXTURE_CACHE_MAX {
|
||||
if let Some(old) = order.pop_front() {
|
||||
cache.remove(&old);
|
||||
}
|
||||
}
|
||||
let bytes = texture_bytes(texture.width(), texture.height());
|
||||
self.gallery
|
||||
.photo_tex
|
||||
.borrow_mut()
|
||||
.insert(uid.to_string(), texture, bytes);
|
||||
}
|
||||
|
||||
/// Mark a cached thumbnail as freshly used, so eviction takes the tiles
|
||||
@@ -208,14 +205,7 @@ impl Ui {
|
||||
/// Insertion order alone evicts the top of the timeline first — exactly what
|
||||
/// a scroll back up then asks for again.
|
||||
fn touch_texture(&self, uid: &str) {
|
||||
let mut order = self.gallery.photo_tex_order.borrow_mut();
|
||||
if order.back().is_some_and(|back| back == uid) {
|
||||
return;
|
||||
}
|
||||
if let Some(at) = order.iter().position(|held| held == uid) {
|
||||
order.remove(at);
|
||||
order.push_back(uid.to_string());
|
||||
}
|
||||
self.gallery.photo_tex.borrow_mut().touch(uid);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -631,8 +621,7 @@ fn build_window(app: &adw::Application) {
|
||||
library: Cell::new(true),
|
||||
page_waiters: RefCell::new(Vec::new()),
|
||||
width: Cell::new(0),
|
||||
photo_tex: RefCell::new(HashMap::new()),
|
||||
photo_tex_order: RefCell::new(VecDeque::new()),
|
||||
photo_tex: RefCell::new(Lru::new(TEXTURE_CACHE_BYTES)),
|
||||
photo_nothumb: RefCell::new(HashSet::new()),
|
||||
thumb_wanted: RefCell::new(HashMap::new()),
|
||||
thumb_queue: RefCell::new(VecDeque::new()),
|
||||
@@ -640,6 +629,7 @@ fn build_window(app: &adw::Application) {
|
||||
thumb_generation: Cell::new(0),
|
||||
decode_queue: RefCell::new(VecDeque::new()),
|
||||
decode_idle: Cell::new(false),
|
||||
decode_inflight: RefCell::default(),
|
||||
thumb_source: RefCell::new(None),
|
||||
relayout_source: RefCell::new(None),
|
||||
bound: RefCell::new(BTreeMap::new()),
|
||||
@@ -652,6 +642,7 @@ fn build_window(app: &adw::Application) {
|
||||
select_btn: gallery_widgets.select_btn.clone(),
|
||||
selection: gallery_widgets.selection.clone(),
|
||||
more: gallery_widgets.more.clone(),
|
||||
gallery_actions: gallery_widgets.gallery_actions.clone(),
|
||||
upload_face: gallery_widgets.upload_face.clone(),
|
||||
float_heading: gallery_widgets.float_heading.clone(),
|
||||
float_label: gallery_widgets.float_label.clone(),
|
||||
@@ -737,6 +728,10 @@ fn build_window(app: &adw::Application) {
|
||||
resume_button: takeout_widgets.resume_button.clone(),
|
||||
inflight: Cell::new(false),
|
||||
running: Cell::new(false),
|
||||
restored: Cell::new(false),
|
||||
save_seq: Cell::new(0),
|
||||
saved_seq: Default::default(),
|
||||
repaint_seq: Cell::new(0),
|
||||
},
|
||||
update,
|
||||
});
|
||||
|
||||
@@ -1,10 +1,32 @@
|
||||
use crate::*;
|
||||
use base64::{Engine, engine::general_purpose::STANDARD};
|
||||
use pdfs_core::control::{GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace};
|
||||
use std::collections::VecDeque;
|
||||
|
||||
const PAGE: usize = 150;
|
||||
/// Decoded thumbnails kept, the least recently shown dropped first.
|
||||
const THUMB_CACHE: usize = 256;
|
||||
/// What a new content width asks of the rows.
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
enum Reflow {
|
||||
/// Nothing changed, or there is no width yet.
|
||||
None,
|
||||
/// The first real width: lay the rows out now, nothing is on screen yet.
|
||||
Now,
|
||||
/// A resize: wait for it to settle, since the rows are rebuilt from
|
||||
/// scratch and a drag resizes on every frame.
|
||||
Debounced,
|
||||
}
|
||||
|
||||
fn reflow_for(previous: i32, width: i32) -> Reflow {
|
||||
if width <= 0 || width == previous {
|
||||
Reflow::None
|
||||
} else if previous <= 0 {
|
||||
Reflow::Now
|
||||
} else {
|
||||
Reflow::Debounced
|
||||
}
|
||||
}
|
||||
|
||||
type ThumbnailKey = (u64, bool, String);
|
||||
type ThumbnailTarget = (glib::WeakRef<gtk4::Picture>, glib::WeakRef<gtk4::Image>);
|
||||
|
||||
@@ -45,12 +67,15 @@ pub(crate) struct Browser {
|
||||
albums: RefCell<Vec<GalleryAlbum>>,
|
||||
items: RefCell<Vec<PhotoItem>>,
|
||||
width: Cell<i32>,
|
||||
/// The pending re-flow after a resize, replaced by each new width.
|
||||
reflow: RefCell<Option<glib::SourceId>>,
|
||||
generation: Cell<u64>,
|
||||
total: Cell<usize>,
|
||||
loading: Cell<bool>,
|
||||
unlocked: Cell<bool>,
|
||||
thumbnail_slots: tokio::sync::Semaphore,
|
||||
thumbnails: RefCell<VecDeque<(bool, String, gtk4::gdk::Texture)>>,
|
||||
/// Decoded thumbnails by whether they are hidden-album ones and uid.
|
||||
thumbnails: RefCell<Lru<(bool, String), gtk4::gdk::Texture>>,
|
||||
thumb_pending: RefCell<HashMap<ThumbnailKey, Vec<ThumbnailTarget>>>,
|
||||
}
|
||||
|
||||
@@ -86,7 +111,7 @@ impl Browser {
|
||||
}
|
||||
self.thumbnails
|
||||
.borrow_mut()
|
||||
.retain(|(private, _, _)| !private);
|
||||
.retain(|(private, _), _| !private);
|
||||
self.thumb_pending.borrow_mut().clear();
|
||||
self.trail.borrow_mut().clear();
|
||||
self.chooser.borrow_mut().take();
|
||||
@@ -552,7 +577,7 @@ impl Browser {
|
||||
if self.chooser.borrow().is_some() {
|
||||
return;
|
||||
}
|
||||
let width = (self.width.get() - 24).max(240);
|
||||
let width = self.width.get().max(240);
|
||||
let columns = ((width + 8) / 216).max(1);
|
||||
let card = (width - 8 * (columns - 1)) / columns;
|
||||
let mut rows = Vec::new();
|
||||
@@ -602,6 +627,13 @@ impl Browser {
|
||||
let generation = self.generation.get();
|
||||
glib::spawn_future_local(async move {
|
||||
let result = reply.recv().await;
|
||||
// Decoded before the checks below, so they see the state after it.
|
||||
let decoded = match &result {
|
||||
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) if private => {
|
||||
decode_thumbnail_off_thread(data.clone()).await
|
||||
}
|
||||
_ => None,
|
||||
};
|
||||
let close = |token| {
|
||||
let _ = spawn_request(
|
||||
browser.ui.dirs.control_socket(),
|
||||
@@ -646,8 +678,8 @@ impl Browser {
|
||||
picture.set_vexpand(true);
|
||||
content.append(&picture);
|
||||
}
|
||||
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) if private => {
|
||||
let Some(texture) = decode_thumbnail(&data) else {
|
||||
Ok(Ok(Response::GalleryThumbnail { data: Some(_) })) if private => {
|
||||
let Some(texture) = decoded else {
|
||||
browser
|
||||
.status
|
||||
.set_label(&gettext("Couldn't open the photo."));
|
||||
@@ -683,13 +715,15 @@ pub(crate) fn wire(
|
||||
hidden: >k4::Button,
|
||||
) {
|
||||
let title = ui.gallery.title.clone();
|
||||
let header = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
|
||||
header.set_halign(gtk4::Align::End);
|
||||
// The page's header bar holds these, beside Select (see `sync_header`).
|
||||
let header = &ui.gallery.gallery_actions;
|
||||
let choose = gtk4::Button::with_label(&gettext("Add This Folder"));
|
||||
choose.set_visible(false);
|
||||
choose.add_css_class("suggested-action");
|
||||
header.append(&choose);
|
||||
let more = gtk4::Button::from_icon_name("view-more-symbolic");
|
||||
more.set_tooltip_text(Some(&gettext("Gallery Options")));
|
||||
more.add_css_class("flat");
|
||||
let unlock = gtk4::Button::with_label(&gettext("Unlock"));
|
||||
unlock.set_visible(false);
|
||||
header.append(&unlock);
|
||||
@@ -709,7 +743,6 @@ pub(crate) fn wire(
|
||||
let status = gtk4::Label::new(None);
|
||||
status.set_wrap(true);
|
||||
let content = gtk4::Box::new(gtk4::Orientation::Vertical, 0);
|
||||
content.append(&header);
|
||||
content.append(&status);
|
||||
content.append(&scroll);
|
||||
ui.gallery
|
||||
@@ -743,12 +776,13 @@ pub(crate) fn wire(
|
||||
albums: RefCell::new(Vec::new()),
|
||||
items: RefCell::new(Vec::new()),
|
||||
width: Cell::new(0),
|
||||
reflow: RefCell::new(None),
|
||||
generation: Cell::new(0),
|
||||
total: Cell::new(0),
|
||||
loading: Cell::new(false),
|
||||
unlocked: Cell::new(false),
|
||||
thumbnail_slots: tokio::sync::Semaphore::new(8),
|
||||
thumbnails: RefCell::default(),
|
||||
thumbnails: RefCell::new(Lru::new(THUMB_CACHE)),
|
||||
thumb_pending: RefCell::default(),
|
||||
});
|
||||
*ui.drive_galleries.borrow_mut() = Rc::downgrade(&browser);
|
||||
@@ -794,12 +828,13 @@ pub(crate) fn wire(
|
||||
return;
|
||||
};
|
||||
let row = data.borrow::<Row>();
|
||||
// The page around the list already keeps its margins, so rows run edge
|
||||
// to edge like the timeline's.
|
||||
let line = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
|
||||
line.set_margin_start(12);
|
||||
line.set_margin_end(12);
|
||||
line.set_margin_bottom(8);
|
||||
match &*row {
|
||||
Row::Heading(label) => {
|
||||
line.set_margin_top(12);
|
||||
let label = gtk4::Label::new(Some(label));
|
||||
label.add_css_class("heading");
|
||||
line.append(&label);
|
||||
@@ -841,7 +876,9 @@ pub(crate) fn wire(
|
||||
}
|
||||
}
|
||||
Row::Media(items) => {
|
||||
// The same gap down as across, as in the timeline.
|
||||
line.set_spacing(super::photos::TILE_GAP);
|
||||
line.set_margin_bottom(super::photos::TILE_GAP);
|
||||
for (item, (width, height)) in items {
|
||||
let button = tile(
|
||||
&browser,
|
||||
@@ -918,11 +955,6 @@ pub(crate) fn wire(
|
||||
let browser = browser.clone();
|
||||
move || browser.close()
|
||||
});
|
||||
} else {
|
||||
menu.item(&gettext("Refresh galleries"), {
|
||||
let browser = browser.clone();
|
||||
move || browser.change(GalleryAction::Refresh)
|
||||
});
|
||||
}
|
||||
if let Some(album) = browser.current().filter(|album| !album.proton) {
|
||||
menu.item(&gettext("Choose Cover"), {
|
||||
@@ -1000,8 +1032,27 @@ pub(crate) fn wire(
|
||||
return glib::ControlFlow::Break;
|
||||
};
|
||||
let width = scroll.width();
|
||||
if width > 0 && browser.width.replace(width) != width {
|
||||
browser.rebuild();
|
||||
match reflow_for(browser.width.get(), width) {
|
||||
Reflow::None => {}
|
||||
Reflow::Now => {
|
||||
browser.width.set(width);
|
||||
browser.rebuild();
|
||||
}
|
||||
Reflow::Debounced => {
|
||||
browser.width.set(width);
|
||||
if let Some(source) = browser.reflow.borrow_mut().take() {
|
||||
source.remove();
|
||||
}
|
||||
let weak = Rc::downgrade(&browser);
|
||||
let source =
|
||||
glib::timeout_add_local_once(super::photos::RELAYOUT_DEBOUNCE, move || {
|
||||
if let Some(browser) = weak.upgrade() {
|
||||
browser.reflow.borrow_mut().take();
|
||||
browser.rebuild();
|
||||
}
|
||||
});
|
||||
*browser.reflow.borrow_mut() = Some(source);
|
||||
}
|
||||
}
|
||||
glib::ControlFlow::Continue
|
||||
}
|
||||
@@ -1089,6 +1140,15 @@ fn decode_thumbnail(data: &str) -> Option<gtk4::gdk::Texture> {
|
||||
gtk4::gdk::Texture::from_bytes(&glib::Bytes::from_owned(bytes)).ok()
|
||||
}
|
||||
|
||||
/// [`decode_thumbnail`] on gio's blocking pool, so neither the base64 nor the
|
||||
/// image decoder runs on the GTK thread.
|
||||
async fn decode_thumbnail_off_thread(data: String) -> Option<gtk4::gdk::Texture> {
|
||||
gio::spawn_blocking(move || decode_thumbnail(&data))
|
||||
.await
|
||||
.ok()
|
||||
.flatten()
|
||||
}
|
||||
|
||||
impl Browser {
|
||||
fn want_thumbnail(
|
||||
self: &Rc<Self>,
|
||||
@@ -1100,20 +1160,17 @@ impl Browser {
|
||||
if private && !self.unlocked.get() {
|
||||
return;
|
||||
}
|
||||
{
|
||||
let mut cache = self.thumbnails.borrow_mut();
|
||||
if let Some(index) = cache
|
||||
.iter()
|
||||
.position(|(p, id, _)| *p == private && id == uid)
|
||||
{
|
||||
let cached = cache.remove(index).unwrap();
|
||||
picture.set_paintable(Some(&cached.2));
|
||||
if let Some(icon) = icon.upgrade() {
|
||||
icon.set_visible(false);
|
||||
}
|
||||
cache.push_back(cached);
|
||||
return;
|
||||
let cached = self
|
||||
.thumbnails
|
||||
.borrow_mut()
|
||||
.fetch(&(private, uid.to_owned()))
|
||||
.cloned();
|
||||
if let Some(texture) = cached {
|
||||
picture.set_paintable(Some(&texture));
|
||||
if let Some(icon) = icon.upgrade() {
|
||||
icon.set_visible(false);
|
||||
}
|
||||
return;
|
||||
}
|
||||
let key = (self.generation.get(), private, uid.to_owned());
|
||||
{
|
||||
@@ -1152,6 +1209,12 @@ impl Browser {
|
||||
},
|
||||
);
|
||||
let response = request.recv().await;
|
||||
let texture = match response {
|
||||
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) => {
|
||||
decode_thumbnail_off_thread(data).await
|
||||
}
|
||||
_ => None,
|
||||
};
|
||||
let targets = browser
|
||||
.thumb_pending
|
||||
.borrow_mut()
|
||||
@@ -1160,9 +1223,7 @@ impl Browser {
|
||||
if key.0 != browser.generation.get() || private && !browser.unlocked.get() {
|
||||
return;
|
||||
}
|
||||
if let Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) = response
|
||||
&& let Some(texture) = decode_thumbnail(&data)
|
||||
{
|
||||
if let Some(texture) = texture {
|
||||
for (picture, icon) in targets {
|
||||
if let Some(picture) = picture.upgrade() {
|
||||
picture.set_paintable(Some(&texture));
|
||||
@@ -1171,12 +1232,27 @@ impl Browser {
|
||||
icon.set_visible(false);
|
||||
}
|
||||
}
|
||||
let mut cache = browser.thumbnails.borrow_mut();
|
||||
if cache.len() >= THUMB_CACHE {
|
||||
cache.pop_front();
|
||||
}
|
||||
cache.push_back((private, key.2, texture));
|
||||
// Capped by count, like before: every entry costs one.
|
||||
browser
|
||||
.thumbnails
|
||||
.borrow_mut()
|
||||
.insert((private, key.2), texture, 1);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{Reflow, reflow_for};
|
||||
|
||||
#[test]
|
||||
fn the_first_width_lays_out_at_once_and_a_resize_waits() {
|
||||
assert_eq!(reflow_for(0, 0), Reflow::None);
|
||||
assert_eq!(reflow_for(0, 800), Reflow::Now);
|
||||
assert_eq!(reflow_for(800, 800), Reflow::None);
|
||||
assert_eq!(reflow_for(800, 760), Reflow::Debounced);
|
||||
// A collapsed widget reports no width; keep the last layout.
|
||||
assert_eq!(reflow_for(800, 0), Reflow::None);
|
||||
}
|
||||
}
|
||||
@@ -160,11 +160,10 @@ pub(crate) struct GalleryState {
|
||||
/// Content width the grid is currently laid out to. Updated when the
|
||||
/// ListView is resized, which re-flows the visible sections.
|
||||
pub(crate) width: Cell<i32>,
|
||||
/// Decoded thumbnails by photo uid, with the insertion order that evicts the
|
||||
/// oldest past [`TEXTURE_CACHE_MAX`]. Scrolling back over a day therefore
|
||||
/// repaints from memory instead of re-decoding from disk.
|
||||
pub(crate) photo_tex: RefCell<HashMap<String, gtk4::gdk::Texture>>,
|
||||
pub(crate) photo_tex_order: RefCell<VecDeque<String>>,
|
||||
/// Decoded thumbnails by photo uid, the least recently used evicted once
|
||||
/// their pixels pass [`TEXTURE_CACHE_BYTES`]. Scrolling back over a day
|
||||
/// therefore repaints from memory instead of re-decoding from disk.
|
||||
pub(crate) photo_tex: RefCell<Lru<String, gtk4::gdk::Texture>>,
|
||||
/// Photos the daemon reported as having no thumbnail at all, so a tile that
|
||||
/// can never be filled isn't requested again on every scroll past it.
|
||||
pub(crate) photo_nothumb: RefCell<HashSet<String>>,
|
||||
@@ -186,12 +185,14 @@ pub(crate) struct GalleryState {
|
||||
pub(crate) thumb_inflight: RefCell<HashSet<String>>,
|
||||
pub(crate) thumb_generation: Cell<u64>,
|
||||
/// Thumbnails on disk waiting to be turned into textures, as `(uid, path)`.
|
||||
/// Decoding happens on the GTK thread (textures are not `Send`), so it is fed
|
||||
/// a few at a time from an idle callback rather than in one blocking burst
|
||||
/// that would stutter the scroll. [`Self::decode_idle`] is the "callback
|
||||
/// already scheduled" guard.
|
||||
/// [`schedule_decode`] decodes them on worker threads a few at a time, so
|
||||
/// the scroll never waits on a JPEG decoder. [`Self::decode_idle`] is the
|
||||
/// "decoder already running" guard, and [`Self::decode_inflight`] the uids
|
||||
/// being decoded right now, so a tile rebound meanwhile doesn't queue its
|
||||
/// photo a second time.
|
||||
pub(crate) decode_queue: RefCell<VecDeque<(String, String)>>,
|
||||
pub(crate) decode_idle: Cell<bool>,
|
||||
pub(crate) decode_inflight: RefCell<HashSet<String>>,
|
||||
/// Pending debounce timers for the thumbnail queue flush and the section
|
||||
/// re-flow, replaced on each new trigger so only the last one fires.
|
||||
pub(crate) thumb_source: RefCell<Option<glib::SourceId>>,
|
||||
@@ -225,6 +226,9 @@ pub(crate) struct GalleryState {
|
||||
/// The header's page menu and the Upload button's face, which drops its
|
||||
/// label in a narrow window.
|
||||
pub(crate) more: gtk4::MenuButton,
|
||||
/// The header's end slot for an open Drive gallery's own buttons (Add
|
||||
/// This Folder, Unlock, options), filled by the Drive gallery browser.
|
||||
pub(crate) gallery_actions: gtk4::Box,
|
||||
pub(crate) upload_face: adw::ButtonContent,
|
||||
/// The section the top of the timeline is in, floating over the grid
|
||||
/// once its own heading has scrolled away.
|
||||
@@ -348,11 +352,23 @@ pub(crate) const THUMB_DEBOUNCE: Duration = Duration::from_millis(60);
|
||||
/// in seconds, not milliseconds.
|
||||
pub(crate) const THUMB_RETRY: Duration = Duration::from_secs(4);
|
||||
|
||||
/// Decoded thumbnails held in memory, evicted least-recently-*used* first. Each
|
||||
/// is a few hundred KiB of GPU texture, and at the justified row density 600 was
|
||||
/// under two screens' worth — a scroll down and back up then had to re-fetch and
|
||||
/// re-decode everything it had just shown.
|
||||
pub(crate) const TEXTURE_CACHE_MAX: usize = 1500;
|
||||
/// Decoded thumbnail pixels held in memory, evicted least-recently-*used*
|
||||
/// first. Budgeted by bytes rather than by count, because one oversized
|
||||
/// thumbnail costs as much as dozens of ordinary ones. A 512 px thumbnail is
|
||||
/// about 600 KiB decoded, so this holds roughly 900 of them: at the justified
|
||||
/// row density 600 was under two screens' worth, and a scroll down and back up
|
||||
/// then had to re-fetch and re-decode everything it had just shown.
|
||||
pub(crate) const TEXTURE_CACHE_BYTES: usize = 512 * 1024 * 1024;
|
||||
|
||||
/// What a decoded texture costs [`TEXTURE_CACHE_BYTES`]: four bytes a pixel.
|
||||
pub(crate) fn texture_bytes(width: i32, height: i32) -> usize {
|
||||
let width = usize::try_from(width).unwrap_or(0);
|
||||
let height = usize::try_from(height).unwrap_or(0);
|
||||
width.saturating_mul(height).saturating_mul(4).max(1)
|
||||
}
|
||||
|
||||
/// How many thumbnails [`schedule_decode`] decodes at once.
|
||||
const DECODE_BATCH: usize = 4;
|
||||
|
||||
/// How many tiles beyond the realised rows [`prefetch_thumbs`] warms, so a tile
|
||||
/// is decoded before it is scrolled onto rather than after.
|
||||
@@ -524,6 +540,7 @@ pub(crate) struct GalleryWidgets {
|
||||
pub(crate) select_btn: gtk4::Button,
|
||||
pub(crate) selection: SelectionBar,
|
||||
pub(crate) more: gtk4::MenuButton,
|
||||
pub(crate) gallery_actions: gtk4::Box,
|
||||
pub(crate) upload_face: adw::ButtonContent,
|
||||
pub(crate) float_heading: gtk4::Revealer,
|
||||
pub(crate) float_label: gtk4::Label,
|
||||
@@ -694,6 +711,12 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) {
|
||||
.build();
|
||||
more.add_css_class("flat");
|
||||
|
||||
// An open Drive gallery's own buttons live in the header too, not in a row
|
||||
// of their own above its grid: that row took height from the photos and
|
||||
// left its button touching the first row of tiles.
|
||||
let gallery_actions = gtk4::Box::new(gtk4::Orientation::Horizontal, 6);
|
||||
gallery_actions.set_visible(false);
|
||||
|
||||
// Picking photos is a mode: the button enters it, and the header then
|
||||
// trades the page's own controls for Cancel and a count, as GNOME apps do.
|
||||
let select_btn = gtk4::Button::builder()
|
||||
@@ -1002,6 +1025,7 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) {
|
||||
header.pack_start(&back);
|
||||
header.pack_start(&upload);
|
||||
header.pack_end(&more);
|
||||
header.pack_end(&gallery_actions);
|
||||
header.pack_end(&select_btn);
|
||||
header.pack_end(&selection.cancel);
|
||||
|
||||
@@ -1031,6 +1055,7 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) {
|
||||
select_btn,
|
||||
selection,
|
||||
more,
|
||||
gallery_actions,
|
||||
upload_face,
|
||||
float_heading,
|
||||
float_label,
|
||||
@@ -1141,6 +1166,7 @@ pub(crate) fn sync_header(ui: &Rc<Ui>) {
|
||||
gallery.back.set_visible(!selecting && collection);
|
||||
gallery.upload.set_visible(!selecting && !collection);
|
||||
gallery.more.set_visible(!selecting && !galleries);
|
||||
gallery.gallery_actions.set_visible(!selecting && galleries);
|
||||
gallery.select_btn.set_visible(!selecting && timeline);
|
||||
gallery.selection.title.set_visible(selecting);
|
||||
gallery.selection.cancel.set_visible(selecting);
|
||||
@@ -3247,6 +3273,7 @@ pub(crate) fn want_thumb(ui: &Rc<Ui>, photo: &PhotoItem, picture: >k4::Picture
|
||||
|
||||
let mut decode = ui.gallery.decode_queue.borrow_mut();
|
||||
if decode.iter().any(|(uid, _)| uid == &photo.uid)
|
||||
|| ui.gallery.decode_inflight.borrow().contains(&photo.uid)
|
||||
|| ui.gallery.thumb_inflight.borrow().contains(&photo.uid)
|
||||
{
|
||||
return;
|
||||
@@ -3438,9 +3465,16 @@ fn prefetch_thumbs(ui: &Rc<Ui>, mut batch: Vec<String>) -> Vec<String> {
|
||||
batch
|
||||
}
|
||||
|
||||
/// Decode queued thumbnails into textures on an idle callback, a few per pass, so
|
||||
/// a big batch fills in progressively instead of freezing the scroll for the
|
||||
/// length of the whole decode.
|
||||
/// Decode queued thumbnails into textures on worker threads, a few at a time,
|
||||
/// and hand each finished texture to the tiles still waiting for it.
|
||||
///
|
||||
/// Decoding a JPEG takes milliseconds; four of them per idle pass on the GTK
|
||||
/// thread were enough to stutter a scroll. The main thread now only picks the
|
||||
/// next batch (visible tiles first) and paints what comes back. A batch that
|
||||
/// lands after the timeline was reset is dropped, and a tile that was rebound
|
||||
/// or unbound meanwhile is no longer in [`GalleryState::thumb_wanted`], so it
|
||||
/// is not painted. [`GalleryState::decode_idle`] is the "decoder running"
|
||||
/// guard.
|
||||
pub(crate) fn schedule_decode(ui: &Rc<Ui>) {
|
||||
if ui.gallery.decode_idle.get() || ui.gallery.decode_queue.borrow().is_empty() {
|
||||
return;
|
||||
@@ -3448,63 +3482,95 @@ pub(crate) fn schedule_decode(ui: &Rc<Ui>) {
|
||||
ui.gallery.decode_idle.set(true);
|
||||
|
||||
let ui = ui.clone();
|
||||
glib::idle_add_local(move || {
|
||||
let batch: Vec<(String, String)> = {
|
||||
let mut queue = ui.gallery.decode_queue.borrow_mut();
|
||||
let wanted = ui.gallery.thumb_wanted.borrow();
|
||||
let list = &ui.gallery.list;
|
||||
let visible = |uid: &str| {
|
||||
wanted.get(uid).is_some_and(|pictures| {
|
||||
pictures.iter().any(|picture| {
|
||||
if !picture.is_mapped() {
|
||||
return false;
|
||||
}
|
||||
!picture.is_ancestor(list)
|
||||
|| picture.compute_bounds(list).is_some_and(|bounds| {
|
||||
bounds.y() + bounds.height() > 0.0
|
||||
&& bounds.y() < list.height() as f32
|
||||
})
|
||||
})
|
||||
})
|
||||
};
|
||||
queue.retain(|(uid, _)| wanted.contains_key(uid));
|
||||
(0..4)
|
||||
.filter_map(|_| {
|
||||
queue
|
||||
.iter()
|
||||
.position(|(uid, _)| visible(uid))
|
||||
.and_then(|index| queue.remove(index))
|
||||
.or_else(|| queue.pop_front())
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
for (uid, path) in batch {
|
||||
if ui.gallery.photo_tex.borrow().contains_key(&uid) {
|
||||
continue;
|
||||
glib::spawn_future_local(async move {
|
||||
loop {
|
||||
let batch = next_decode_batch(&ui);
|
||||
if batch.is_empty() {
|
||||
break;
|
||||
}
|
||||
let texture = match gtk4::gdk::Texture::from_filename(&path) {
|
||||
Ok(texture) => texture,
|
||||
Err(e) => {
|
||||
tracing::debug!("cannot decode thumbnail {path}: {e}");
|
||||
ui.gallery.photo_nothumb.borrow_mut().insert(uid);
|
||||
let generation = ui.gallery.thumb_generation.get();
|
||||
ui.gallery
|
||||
.decode_inflight
|
||||
.borrow_mut()
|
||||
.extend(batch.iter().map(|(uid, _)| uid.clone()));
|
||||
// All of the batch decodes at once, on the worker pool; the results
|
||||
// are collected in the order they were picked.
|
||||
let jobs: Vec<_> = batch
|
||||
.into_iter()
|
||||
.map(|(uid, path)| {
|
||||
let job = gio::spawn_blocking({
|
||||
let path = path.clone();
|
||||
move || gtk4::gdk::Texture::from_filename(&path)
|
||||
});
|
||||
(uid, path, job)
|
||||
})
|
||||
.collect();
|
||||
for (uid, path, job) in jobs {
|
||||
let decoded = job.await;
|
||||
ui.gallery.decode_inflight.borrow_mut().remove(&uid);
|
||||
if generation != ui.gallery.thumb_generation.get() {
|
||||
continue;
|
||||
}
|
||||
};
|
||||
ui.store_texture(&uid, texture.clone());
|
||||
let waiting = ui.gallery.thumb_wanted.borrow_mut().remove(&uid);
|
||||
for picture in waiting.into_iter().flatten() {
|
||||
picture.set_paintable(Some(&texture));
|
||||
let texture = match decoded {
|
||||
Ok(Ok(texture)) => texture,
|
||||
Ok(Err(e)) => {
|
||||
tracing::debug!("cannot decode thumbnail {path}: {e}");
|
||||
ui.gallery.photo_nothumb.borrow_mut().insert(uid);
|
||||
continue;
|
||||
}
|
||||
Err(_) => {
|
||||
tracing::debug!("thumbnail decoder for {path} panicked");
|
||||
ui.gallery.photo_nothumb.borrow_mut().insert(uid);
|
||||
continue;
|
||||
}
|
||||
};
|
||||
if ui.gallery.photo_tex.borrow().contains_key(&uid) {
|
||||
continue;
|
||||
}
|
||||
ui.store_texture(&uid, texture.clone());
|
||||
let waiting = ui.gallery.thumb_wanted.borrow_mut().remove(&uid);
|
||||
for picture in waiting.into_iter().flatten() {
|
||||
picture.set_paintable(Some(&texture));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ui.gallery.decode_queue.borrow().is_empty() {
|
||||
ui.gallery.decode_idle.set(false);
|
||||
return glib::ControlFlow::Break;
|
||||
}
|
||||
glib::ControlFlow::Continue
|
||||
ui.gallery.decode_idle.set(false);
|
||||
});
|
||||
}
|
||||
|
||||
/// Take the next few thumbnails to decode off the queue: the ones on screen
|
||||
/// first, then in queue order, skipping tiles nobody waits for any more and
|
||||
/// photos already decoded.
|
||||
fn next_decode_batch(ui: &Rc<Ui>) -> Vec<(String, String)> {
|
||||
let mut queue = ui.gallery.decode_queue.borrow_mut();
|
||||
let wanted = ui.gallery.thumb_wanted.borrow();
|
||||
let cached = ui.gallery.photo_tex.borrow();
|
||||
let list = &ui.gallery.list;
|
||||
let visible = |uid: &str| {
|
||||
wanted.get(uid).is_some_and(|pictures| {
|
||||
pictures.iter().any(|picture| {
|
||||
if !picture.is_mapped() {
|
||||
return false;
|
||||
}
|
||||
!picture.is_ancestor(list)
|
||||
|| picture.compute_bounds(list).is_some_and(|bounds| {
|
||||
bounds.y() + bounds.height() > 0.0 && bounds.y() < list.height() as f32
|
||||
})
|
||||
})
|
||||
})
|
||||
};
|
||||
queue.retain(|(uid, _)| wanted.contains_key(uid) && !cached.contains_key(uid));
|
||||
(0..DECODE_BATCH)
|
||||
.filter_map(|_| {
|
||||
queue
|
||||
.iter()
|
||||
.position(|(uid, _)| visible(uid))
|
||||
.and_then(|index| queue.remove(index))
|
||||
.or_else(|| queue.pop_front())
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Re-flow the sections on screen shortly. Debounced, because the triggers (a
|
||||
/// window resize, a zoom step) arrive in floods and only the final state
|
||||
/// matters.
|
||||
@@ -4774,13 +4840,23 @@ pub(crate) fn gallery_unreachable(ui: &Rc<Ui>) {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{
|
||||
Grouping, PHOTOS_PAGE, ROW_DEFAULT, ROW_MAX, ROW_MIN, ROW_STEP, TILE_GAP, TILE_RATIO_MAX,
|
||||
TILE_RATIO_MIN, active_filters, copy_without_overwrite, empty_timeline_text, grouping_for,
|
||||
memory_years, month_index, month_range, plan_grid, plan_justified, section_heading,
|
||||
tile_ratio, viewport_unfilled,
|
||||
Grouping, PHOTOS_PAGE, ROW_DEFAULT, ROW_MAX, ROW_MIN, ROW_STEP, TEXTURE_CACHE_BYTES,
|
||||
TILE_GAP, TILE_RATIO_MAX, TILE_RATIO_MIN, active_filters, copy_without_overwrite,
|
||||
empty_timeline_text, grouping_for, memory_years, month_index, month_range, plan_grid,
|
||||
plan_justified, section_heading, texture_bytes, tile_ratio, viewport_unfilled,
|
||||
};
|
||||
use pdfs_core::control::{PhotoItem, PhotoKind, PhotoMonth};
|
||||
|
||||
#[test]
|
||||
fn the_texture_cache_is_budgeted_by_decoded_pixels() {
|
||||
assert_eq!(texture_bytes(512, 384), 512 * 384 * 4);
|
||||
// A broken size still costs something, so it can't pile up for free.
|
||||
assert_eq!(texture_bytes(0, 512), 1);
|
||||
assert_eq!(texture_bytes(-1, -1), 1);
|
||||
// Ordinary thumbnails: well over two dense screens' worth fit.
|
||||
assert!(TEXTURE_CACHE_BYTES / texture_bytes(512, 384) >= 600);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_scrubber_finds_the_month_a_photo_was_taken_in() {
|
||||
let months = [(2026, 3), (2025, 12), (2025, 11)].map(|(year, month)| PhotoMonth {
|
||||
|
||||
@@ -17,6 +17,8 @@
|
||||
//! a single photo opens it in its town, and photos taken on one spot, which
|
||||
//! never part, are listed to pick from.
|
||||
|
||||
// Markers merge the same way in every Proton gallery app.
|
||||
use proton_gallery_rs::places::{Bubble, bubble_radius, cluster, compact_count};
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::path::PathBuf;
|
||||
use std::sync::OnceLock;
|
||||
@@ -67,6 +69,11 @@ const COVER_PX: i32 = 128;
|
||||
/// How many street-map tiles stay in memory.
|
||||
const TILE_CACHE: usize = 160;
|
||||
|
||||
/// Photo marker covers kept, 64 KiB each. A town's own cover is never
|
||||
/// dropped (it only arrives with the town's card), but the photos zoomed past
|
||||
/// one by one would otherwise pile up for as long as the map is open.
|
||||
const COVER_CACHE: usize = 1024;
|
||||
|
||||
/// How long a tile that couldn't be had is left alone before it is tried
|
||||
/// again.
|
||||
const TILE_RETRY: Duration = Duration::from_secs(60);
|
||||
@@ -132,13 +139,6 @@ fn parse_ring(line: &str) -> Option<Ring> {
|
||||
Some(Ring { points, min, max })
|
||||
}
|
||||
|
||||
/// Radius in px of a marker holding `photos` photos: big enough to make the
|
||||
/// photo out, and growing with the count, but slowly, so a home town with
|
||||
/// thousands doesn't cover a continent.
|
||||
fn bubble_radius(photos: usize) -> f64 {
|
||||
18.0 + 2.0 * (photos.max(1) as f64).ln()
|
||||
}
|
||||
|
||||
/// What the map shows: which part of the world, at what size.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
struct View {
|
||||
@@ -190,17 +190,6 @@ struct Marker {
|
||||
target: Target,
|
||||
}
|
||||
|
||||
/// One marker as last drawn, standing for one or more [`Marker`]s: where, how
|
||||
/// big, and which (indices into [`MapState::markers`], the one with the most
|
||||
/// photos first).
|
||||
struct Bubble {
|
||||
x: f64,
|
||||
y: f64,
|
||||
radius: f64,
|
||||
photos: usize,
|
||||
members: Vec<usize>,
|
||||
}
|
||||
|
||||
/// A street-map tile ready to draw, and the names on it.
|
||||
struct CachedTile {
|
||||
surface: cairo::ImageSurface,
|
||||
@@ -232,8 +221,11 @@ struct MapState {
|
||||
/// for from close up.
|
||||
locations: HashMap<u32, Vec<(PhotoItem, World)>>,
|
||||
asked_locations: HashSet<u32>,
|
||||
/// Marker photos, scaled and cropped to a square, by photo uid.
|
||||
covers: HashMap<String, cairo::ImageSurface>,
|
||||
/// Marker photos, scaled and cropped to a square, by photo uid, with the
|
||||
/// draw they were last shown in.
|
||||
covers: HashMap<String, (cairo::ImageSurface, u64)>,
|
||||
/// Counts draws, for dropping the covers shown longest ago.
|
||||
draws: u64,
|
||||
asked_thumbs: HashSet<String>,
|
||||
view: View,
|
||||
/// False until the view has been fitted to the places at a real size, and
|
||||
@@ -349,6 +341,7 @@ impl PlacesMap {
|
||||
locations: HashMap::new(),
|
||||
asked_locations: HashSet::new(),
|
||||
covers: HashMap::new(),
|
||||
draws: 0,
|
||||
asked_thumbs: HashSet::new(),
|
||||
view: View {
|
||||
center: World { x: 0.5, y: 0.5 },
|
||||
@@ -486,7 +479,18 @@ impl PlacesMap {
|
||||
let Some(cover) = square_cover(texture) else {
|
||||
return;
|
||||
};
|
||||
self.state.borrow_mut().covers.insert(uid.to_owned(), cover);
|
||||
let mut state = self.state.borrow_mut();
|
||||
let state = &mut *state;
|
||||
state.covers.insert(uid.to_owned(), (cover, state.draws));
|
||||
let towns: HashSet<&str> = state
|
||||
.places
|
||||
.iter()
|
||||
.map(|(place, _)| place.cover.uid.as_str())
|
||||
.collect();
|
||||
for dropped in evict_covers(&mut state.covers, &towns, state.draws) {
|
||||
// Asked for again once it is back on screen.
|
||||
state.asked_thumbs.remove(&dropped);
|
||||
}
|
||||
self.area.queue_draw();
|
||||
}
|
||||
|
||||
@@ -840,6 +844,7 @@ impl PlacesMap {
|
||||
let mut state = self.state.borrow_mut();
|
||||
let state = &mut *state;
|
||||
let view = state.view;
|
||||
state.draws += 1;
|
||||
paint_outline(cr, view, size, colors);
|
||||
let labels = match state.online.as_mut() {
|
||||
Some(online) => paint_tiles(cr, online, view, size, dark, area.scale_factor()),
|
||||
@@ -863,7 +868,10 @@ impl PlacesMap {
|
||||
}
|
||||
for bubble in &state.bubbles {
|
||||
let marker = &state.markers[bubble.members[0]];
|
||||
let cover = state.covers.get(&marker.cover);
|
||||
let cover = state.covers.get_mut(&marker.cover).map(|(cover, drawn)| {
|
||||
*drawn = state.draws;
|
||||
&*cover
|
||||
});
|
||||
if cover.is_none()
|
||||
&& let Target::Photo { place, index } = marker.target
|
||||
&& state.asked_thumbs.insert(marker.cover.clone())
|
||||
@@ -1121,6 +1129,35 @@ fn evict(cache: &mut HashMap<TileKey, CachedTile>, frame: u64) {
|
||||
}
|
||||
}
|
||||
|
||||
/// Drop the photo covers drawn longest ago, down to [`COVER_CACHE`]. Never
|
||||
/// one drawn in the current draw, and never a town's cover. Returns the uids
|
||||
/// dropped.
|
||||
fn evict_covers<T>(
|
||||
covers: &mut HashMap<String, (T, u64)>,
|
||||
towns: &HashSet<&str>,
|
||||
draw: u64,
|
||||
) -> Vec<String> {
|
||||
if covers.len() <= COVER_CACHE {
|
||||
return Vec::new();
|
||||
}
|
||||
let mut ages: Vec<(u64, &String)> = covers
|
||||
.iter()
|
||||
.filter(|(uid, (_, drawn))| *drawn < draw && !towns.contains(uid.as_str()))
|
||||
.map(|(uid, (_, drawn))| (*drawn, uid))
|
||||
.collect();
|
||||
ages.sort_unstable_by_key(|(drawn, _)| *drawn);
|
||||
let excess = covers.len() - COVER_CACHE;
|
||||
let dropped: Vec<String> = ages
|
||||
.into_iter()
|
||||
.take(excess)
|
||||
.map(|(_, uid)| uid.clone())
|
||||
.collect();
|
||||
for uid in &dropped {
|
||||
covers.remove(uid);
|
||||
}
|
||||
dropped
|
||||
}
|
||||
|
||||
/// Set the names of the tiles on screen, the most important first, leaving
|
||||
/// out any that would overlap one already set.
|
||||
fn paint_labels(
|
||||
@@ -1595,52 +1632,6 @@ fn spread(points: &[World]) -> f64 {
|
||||
span(&mut xs.into_iter()).max(span(&mut ys.into_iter()))
|
||||
}
|
||||
|
||||
/// Merge markers whose circles would overlap on screen, the one with the
|
||||
/// most photos claiming its neighbours (the first of equals, when counts
|
||||
/// tie). Markers off screen are left out.
|
||||
fn cluster(screen: &[(f64, f64)], counts: &[usize], width: f64, height: f64) -> Vec<Bubble> {
|
||||
let mut order: Vec<usize> = (0..screen.len()).collect();
|
||||
order.sort_by(|a, b| counts[*b].cmp(&counts[*a]));
|
||||
let mut bubbles: Vec<Bubble> = Vec::new();
|
||||
for index in order {
|
||||
let (x, y) = screen[index];
|
||||
let reach = bubble_radius(counts[index]);
|
||||
if x < -reach || y < -reach || x > width + reach || y > height + reach {
|
||||
continue;
|
||||
}
|
||||
match bubbles
|
||||
.iter_mut()
|
||||
.find(|b| (b.x - x).hypot(b.y - y) < b.radius + reach * 0.5)
|
||||
{
|
||||
Some(bubble) => {
|
||||
bubble.photos += counts[index];
|
||||
bubble.radius = bubble_radius(bubble.photos);
|
||||
bubble.members.push(index);
|
||||
}
|
||||
None => bubbles.push(Bubble {
|
||||
x,
|
||||
y,
|
||||
radius: reach,
|
||||
photos: counts[index],
|
||||
members: vec![index],
|
||||
}),
|
||||
}
|
||||
}
|
||||
// Smallest last, so a small marker next to a big one stays clickable.
|
||||
bubbles.sort_by(|a, b| b.radius.total_cmp(&a.radius));
|
||||
bubbles
|
||||
}
|
||||
|
||||
/// "7", "840", "1.2k", "35k": short enough to fit a marker. Digits and the
|
||||
/// "k" read the same in every language the app ships.
|
||||
fn compact_count(n: usize) -> String {
|
||||
match n {
|
||||
0..1_000 => n.to_string(),
|
||||
1_000..10_000 => format!("{:.1}k", n as f64 / 1_000.0),
|
||||
_ => format!("{}k", n / 1_000),
|
||||
}
|
||||
}
|
||||
|
||||
fn set_color(cr: &cairo::Context, color: >k4::gdk::RGBA, alpha: f32) {
|
||||
cr.set_source_rgba(
|
||||
f64::from(color.red()),
|
||||
@@ -1654,6 +1645,28 @@ fn set_color(cr: &cairo::Context, color: >k4::gdk::RGBA, alpha: f32) {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn covers_past_the_cap_drop_the_stalest_photos_but_no_town() {
|
||||
let mut covers: HashMap<String, ((), u64)> = (0..COVER_CACHE as u64 + 3)
|
||||
.map(|n| (format!("p{n}"), ((), n)))
|
||||
.collect();
|
||||
let towns: HashSet<&str> = ["p0"].into_iter().collect();
|
||||
let mut dropped = evict_covers(&mut covers, &towns, COVER_CACHE as u64);
|
||||
dropped.sort();
|
||||
assert_eq!(dropped, ["p1", "p2", "p3"]);
|
||||
assert_eq!(covers.len(), COVER_CACHE);
|
||||
assert!(covers.contains_key("p0"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn covers_drawn_this_frame_are_kept_even_past_the_cap() {
|
||||
let mut covers: HashMap<String, ((), u64)> = (0..COVER_CACHE + 2)
|
||||
.map(|n| (format!("p{n}"), ((), 7)))
|
||||
.collect();
|
||||
assert!(evict_covers(&mut covers, &HashSet::new(), 7).is_empty());
|
||||
assert_eq!(covers.len(), COVER_CACHE + 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn projection_puts_the_equator_and_meridian_in_the_middle() {
|
||||
let p = project(0.0, 0.0);
|
||||
|
||||
@@ -52,8 +52,9 @@ fn staged_path(ui: &Rc<Ui>) -> PathBuf {
|
||||
|
||||
/// Read the remembered set, dropping any archive that has since been moved or
|
||||
/// deleted — a stale path would only fail at launch, and silently is worse.
|
||||
fn load_staged(ui: &Rc<Ui>) -> Vec<PathBuf> {
|
||||
let Ok(text) = std::fs::read_to_string(staged_path(ui)) else {
|
||||
/// Blocking: run it off the GTK thread.
|
||||
fn load_staged(path: &Path) -> Vec<PathBuf> {
|
||||
let Ok(text) = std::fs::read_to_string(path) else {
|
||||
return Vec::new();
|
||||
};
|
||||
let paths: Vec<String> = serde_json::from_str(&text).unwrap_or_default();
|
||||
@@ -64,9 +65,39 @@ fn load_staged(ui: &Rc<Ui>) -> Vec<PathBuf> {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Restore whatever was staged when the window last closed, read on a worker.
|
||||
/// Anything the user staged meanwhile is kept alongside it.
|
||||
fn restore_staged(ui: &Rc<Ui>) {
|
||||
let path = staged_path(ui);
|
||||
let ui = ui.clone();
|
||||
glib::spawn_future_local(async move {
|
||||
let restored = gio::spawn_blocking(move || load_staged(&path))
|
||||
.await
|
||||
.unwrap_or_default();
|
||||
{
|
||||
let mut staged = ui.takeout.archives.borrow_mut();
|
||||
for path in restored {
|
||||
if !staged.contains(&path) {
|
||||
staged.push(path);
|
||||
}
|
||||
}
|
||||
staged.sort();
|
||||
}
|
||||
ui.takeout.restored.set(true);
|
||||
repaint_archives(&ui);
|
||||
});
|
||||
}
|
||||
|
||||
/// Remember the staged set. Best-effort: failing to write it costs the user a
|
||||
/// re-pick next time, which is not worth interrupting them over now.
|
||||
///
|
||||
/// Written on a worker. Nothing is written before the remembered set has been
|
||||
/// read back, so the empty list shown meanwhile can't overwrite it, and a
|
||||
/// write that lands after a newer one is skipped.
|
||||
fn save_staged(ui: &Rc<Ui>) {
|
||||
if !ui.takeout.restored.get() {
|
||||
return;
|
||||
}
|
||||
let paths: Vec<String> = ui
|
||||
.takeout
|
||||
.archives
|
||||
@@ -75,12 +106,24 @@ fn save_staged(ui: &Rc<Ui>) {
|
||||
.map(|p| p.display().to_string())
|
||||
.collect();
|
||||
let path = staged_path(ui);
|
||||
let written = serde_json::to_string(&paths)
|
||||
.map_err(|e| e.to_string())
|
||||
.and_then(|text| std::fs::write(&path, text).map_err(|e| e.to_string()));
|
||||
if let Err(e) = written {
|
||||
tracing::warn!("cannot remember staged Takeout archives: {e}");
|
||||
}
|
||||
let seq = ui.takeout.save_seq.get() + 1;
|
||||
ui.takeout.save_seq.set(seq);
|
||||
let saved = ui.takeout.saved_seq.clone();
|
||||
gio::spawn_blocking(move || {
|
||||
let Ok(mut last) = saved.lock() else {
|
||||
return;
|
||||
};
|
||||
if *last > seq {
|
||||
return;
|
||||
}
|
||||
*last = seq;
|
||||
let written = serde_json::to_string(&paths)
|
||||
.map_err(|e| e.to_string())
|
||||
.and_then(|text| std::fs::write(&path, text).map_err(|e| e.to_string()));
|
||||
if let Err(e) = written {
|
||||
tracing::warn!("cannot remember staged Takeout archives: {e}");
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
fn empty_list_description() -> String {
|
||||
@@ -121,6 +164,16 @@ pub(crate) struct TakeoutState {
|
||||
pub(crate) inflight: Cell<bool>,
|
||||
/// Whether the daemon reported an import running on the last poll.
|
||||
pub(crate) running: Cell<bool>,
|
||||
/// Whether the remembered staged set has been read back yet; until then
|
||||
/// nothing is saved over it.
|
||||
pub(crate) restored: Cell<bool>,
|
||||
/// The last save started, and the last one written by a worker, so an
|
||||
/// older save that lands late doesn't overwrite a newer one.
|
||||
pub(crate) save_seq: Cell<u64>,
|
||||
pub(crate) saved_seq: std::sync::Arc<std::sync::Mutex<u64>>,
|
||||
/// Bumped by every repaint of the archive list, so the sizes of an older
|
||||
/// list that arrive late are not painted over a newer one.
|
||||
pub(crate) repaint_seq: Cell<u64>,
|
||||
}
|
||||
|
||||
/// Widgets the Import page hands back for wiring.
|
||||
@@ -490,10 +543,10 @@ pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
|
||||
.back_button
|
||||
.connect_clicked(move |_| ui_back.stack.set_visible_child_name("gallery"));
|
||||
|
||||
// Restore whatever was staged when the window last closed, before the first
|
||||
// paint, so the page comes up as the user left it.
|
||||
*ui.takeout.archives.borrow_mut() = load_staged(ui);
|
||||
// Restore whatever was staged when the window last closed, so the page
|
||||
// comes up as the user left it.
|
||||
repaint_archives(ui);
|
||||
restore_staged(ui);
|
||||
}
|
||||
|
||||
/// Stage `paths`, keeping only `.zip` files and skipping ones already staged.
|
||||
@@ -503,15 +556,36 @@ pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
|
||||
/// the scan reads the archives' central directories, and an extracted tree has
|
||||
/// none — silently importing half of it would be worse than saying no.
|
||||
pub(crate) fn add_archives(ui: &Rc<Ui>, paths: Vec<PathBuf>) {
|
||||
// Whether each is a regular file is asked of the filesystem, which may be
|
||||
// a slow network mount: on a worker.
|
||||
let ui = ui.clone();
|
||||
glib::spawn_future_local(async move {
|
||||
let checked = gio::spawn_blocking(move || {
|
||||
paths
|
||||
.into_iter()
|
||||
.map(|path| {
|
||||
let file = path.is_file();
|
||||
(path, file)
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
})
|
||||
.await
|
||||
.unwrap_or_default();
|
||||
stage_archives(&ui, checked);
|
||||
});
|
||||
}
|
||||
|
||||
/// Stage the archives [`add_archives`] checked, as `(path, is a file)`.
|
||||
fn stage_archives(ui: &Rc<Ui>, paths: Vec<(PathBuf, bool)>) {
|
||||
let mut added = 0usize;
|
||||
let mut rejected = 0usize;
|
||||
{
|
||||
let mut staged = ui.takeout.archives.borrow_mut();
|
||||
for path in paths {
|
||||
for (path, file) in paths {
|
||||
let is_zip = path
|
||||
.extension()
|
||||
.is_some_and(|ext| ext.eq_ignore_ascii_case("zip"));
|
||||
if !is_zip || !path.is_file() {
|
||||
if !is_zip || !file {
|
||||
rejected += 1;
|
||||
continue;
|
||||
}
|
||||
@@ -542,12 +616,44 @@ pub(crate) fn add_archives(ui: &Rc<Ui>, paths: Vec<PathBuf>) {
|
||||
}
|
||||
|
||||
/// Rebuild the staged-archive list and re-derive which actions are available.
|
||||
///
|
||||
/// The archives' sizes are read on a worker, and the list is rebuilt once
|
||||
/// they are in.
|
||||
pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
|
||||
let seq = ui.takeout.repaint_seq.get().wrapping_add(1);
|
||||
ui.takeout.repaint_seq.set(seq);
|
||||
let staged = ui.takeout.archives.borrow().clone();
|
||||
save_staged(ui);
|
||||
sync_takeout_actions(ui);
|
||||
if staged.is_empty() {
|
||||
paint_archives(ui, Vec::new());
|
||||
return;
|
||||
}
|
||||
let ui = ui.clone();
|
||||
glib::spawn_future_local(async move {
|
||||
let sized = gio::spawn_blocking(move || {
|
||||
staged
|
||||
.into_iter()
|
||||
.map(|path| {
|
||||
let size = std::fs::metadata(&path).map(|m| m.len()).unwrap_or(0);
|
||||
(path, size)
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
})
|
||||
.await
|
||||
.unwrap_or_default();
|
||||
if ui.takeout.repaint_seq.get() == seq {
|
||||
paint_archives(&ui, sized);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Fill the staged-archive list with `staged`, as `(path, size)`.
|
||||
fn paint_archives(ui: &Rc<Ui>, staged: Vec<(PathBuf, u64)>) {
|
||||
for row in ui.takeout.rows.borrow_mut().drain(..) {
|
||||
ui.takeout.list_group.remove(&row);
|
||||
}
|
||||
|
||||
let staged = ui.takeout.archives.borrow().clone();
|
||||
let mut rows: Vec<adw::PreferencesRow> = Vec::new();
|
||||
if staged.is_empty() {
|
||||
ui.takeout
|
||||
@@ -558,8 +664,8 @@ pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
|
||||
rows.push(row.upcast());
|
||||
} else {
|
||||
let mut total = 0u64;
|
||||
for path in &staged {
|
||||
let size = std::fs::metadata(path).map(|m| m.len()).unwrap_or(0);
|
||||
for (path, size) in &staged {
|
||||
let size = *size;
|
||||
total += size;
|
||||
let row = adw::ActionRow::builder()
|
||||
.title(
|
||||
@@ -601,9 +707,6 @@ pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
|
||||
)));
|
||||
}
|
||||
*ui.takeout.rows.borrow_mut() = rows;
|
||||
|
||||
save_staged(ui);
|
||||
sync_takeout_actions(ui);
|
||||
}
|
||||
|
||||
/// Enable exactly the actions that make sense right now: nothing to launch
|
||||
|
||||
+2
-2
@@ -13,8 +13,8 @@ scratch (user data in `staging/` and `recovery/` is never touched by this).
|
||||
|
||||
### Changed
|
||||
|
||||
- Signing in runs through `proton_auth_rs::session`, the sequence Proton Gallery and
|
||||
Proton Stream use too. The stored session, the lock/unlock choice for two-password
|
||||
- Signing in runs through `proton_sdk::login` (proton-sdk 0.12.2), the sequence Proton
|
||||
Gallery and Proton Stream use too. The stored session, the lock/unlock choice for two-password
|
||||
accounts, the three mailbox-password tries and the messages stay as they were.
|
||||
- An account whose only second factor is a security key now gets a clear message at
|
||||
sign-in instead of a code prompt that could only fail.
|
||||
|
||||
+620
-488
File diff suppressed because it is too large.
Load diff
+603
-478
File diff suppressed because it is too large.
Load diff
+615
-483
File diff suppressed because it is too large.
Load diff
Reference in new issue
Block a user