custom-gui-packages/pikman-update-manager
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: custom-gui-packages:f33d2254f0c9429d454987b87994c03318c3237f
Branches Tags
custom-gui-packages:main
..
compare: custom-gui-packages:650093da6721edb5b54938296a9d484931f9ae49
Branches Tags
custom-gui-packages:main

No commits in common. "f33d2254f0c9429d454987b87994c03318c3237f" and "650093da6721edb5b54938296a9d484931f9ae49" have entirely different histories.
f33d2254f0 ... 650093da67

12 changed files with 414 additions and 457 deletions
Show Stats Expand all files Collapse all files

2
.github/release-nest-v3 vendored
View File

@ -1 +1 @@
13 11

44
Cargo.lock generated
View File

@ -526,7 +526,7 @@ version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "38e2275cc4e4fc009b0669731a1e5ab7ebf11f469eaede2bab9309a5b4d6057f" checksum = "38e2275cc4e4fc009b0669731a1e5ab7ebf11f469eaede2bab9309a5b4d6057f"
dependencies = [ dependencies = [
"memoffset 0.9.1", "memoffset",
"rustc_version 0.4.0", "rustc_version 0.4.0",
] ]
@ -1441,15 +1441,6 @@ version = "2.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
[[package]]
name = "memoffset"
version = "0.6.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
dependencies = [
"autocfg",
]
[[package]] [[package]]
name = "memoffset" name = "memoffset"
version = "0.9.1" version = "0.9.1"
@ -1555,19 +1546,6 @@ dependencies = [
"winapi 0.3.9", "winapi 0.3.9",
] ]
[[package]]
name = "nix"
version = "0.23.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f3790c00a0150112de0f4cd161e3d7fc4b2d8a5542ffc35f099a2562aecb35c"
dependencies = [
"bitflags 1.3.2",
"cc",
"cfg-if 1.0.0",
"libc",
"memoffset 0.6.5",
]
[[package]] [[package]]
name = "normpath" name = "normpath"
version = "1.2.0" version = "1.2.0"
@ -1781,7 +1759,6 @@ dependencies = [
"rust-i18n", "rust-i18n",
"serde", "serde",
"serde_json", "serde_json",
"single-instance",
"strfmt", "strfmt",
"tokio", "tokio",
"tokio-uds", "tokio-uds",
@ -2246,19 +2223,6 @@ dependencies = [
"libc", "libc",
] ]
[[package]]
name = "single-instance"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4637485391f8545c9d3dbf60f9d9aab27a90c789a700999677583bcb17c8795d"
dependencies = [
"libc",
"nix",
"thiserror",
"widestring",
"winapi 0.3.9",
]
[[package]] [[package]]
name = "slab" name = "slab"
version = "0.4.9" version = "0.4.9"
@ -2899,12 +2863,6 @@ dependencies = [
"wasm-bindgen", "wasm-bindgen",
] ]
[[package]]
name = "widestring"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c168940144dd21fd8046987c16a46a33d5fc84eec29ef9dcddc2ac9e31526b7c"
[[package]] [[package]]
name = "winapi" name = "winapi"
version = "0.2.8" version = "0.2.8"

1
Cargo.toml
View File

@ -45,5 +45,4 @@ reqwest = { version = "0.11", features = ["blocking"] }
strfmt = "0.2.4" strfmt = "0.2.4"
configparser = "3.1.0" configparser = "3.1.0"
ksni = "0.2.2" ksni = "0.2.2"
single-instance = "0.3.3"

2
debian/changelog vendored
View File

@ -1,4 +1,4 @@
pikman-update-manager (1.0.1-100pika4) pikauwu; urgency=medium pikman-update-manager (1.0.1-100pika2) pikauwu; urgency=medium
* initial release * initial release

4
src/bin/apt/apt_full_upgrade/main.rs
View File

@ -4,8 +4,8 @@ use pika_unixsocket_tools::pika_unixsocket_tools::*;
use rust_apt::cache::Upgrade; use rust_apt::cache::Upgrade;
use rust_apt::new_cache; use rust_apt::new_cache;
use rust_apt::progress::{AcquireProgress, InstallProgress}; use rust_apt::progress::{AcquireProgress, InstallProgress};
use std::env;
use tokio::runtime::Runtime; use tokio::runtime::Runtime;
use std::env;
// Init translations for current crate. // Init translations for current crate.
#[macro_use] #[macro_use]
@ -82,7 +82,7 @@ fn main() {
let mut install_progress = InstallProgress::new(AptInstallProgressSocket::new( let mut install_progress = InstallProgress::new(AptInstallProgressSocket::new(
percent_socket_path, percent_socket_path,
status_socket_path, status_socket_path,
error_strfmt_trans_str, &error_strfmt_trans_str,
)); ));
apt_upgrade_cache.resolve(true).unwrap(); apt_upgrade_cache.resolve(true).unwrap();

8
src/bin/apt/apt_update/main.rs
View File

@ -2,8 +2,8 @@ use pika_unixsocket_tools::apt_update_progress_socket::AptUpdateProgressSocket;
use pika_unixsocket_tools::pika_unixsocket_tools::*; use pika_unixsocket_tools::pika_unixsocket_tools::*;
use rust_apt::new_cache; use rust_apt::new_cache;
use rust_apt::progress::AcquireProgress; use rust_apt::progress::AcquireProgress;
use std::env;
use tokio::runtime::Runtime; use tokio::runtime::Runtime;
use std::env;
// Init translations for current crate. // Init translations for current crate.
#[macro_use] #[macro_use]
@ -13,10 +13,6 @@ i18n!("locales", fallback = "en_US");
fn main() { fn main() {
let args: Vec<String> = env::args().collect(); let args: Vec<String> = env::args().collect();
rust_i18n::set_locale(&args[1]); rust_i18n::set_locale(&args[1]);
let instance = single_instance::SingleInstance::new(
"com.github.pikaos-linux.pikmanupdatemanager.update.manager",
)
.unwrap();
let hit_strfmt_trans_str = t!("apt_update_str_hit").to_string(); let hit_strfmt_trans_str = t!("apt_update_str_hit").to_string();
let fetch_strfmt_trans_str = t!("apt_update_str_fetch").to_string(); let fetch_strfmt_trans_str = t!("apt_update_str_fetch").to_string();
@ -45,6 +41,4 @@ fn main() {
panic!("{}", e.to_string()) panic!("{}", e.to_string())
} }
}; };
assert!(!instance.is_single());
} }

143
src/bin/gui/apt_update_page/mod.rs
View File

@ -65,42 +65,24 @@ pub fn apt_update_page(
}); });
thread::spawn(move || { thread::spawn(move || {
let instance = single_instance::SingleInstance::new( let apt_update_command = Command::new("pkexec")
"com.github.pikaos-linux.pikmanupdatemanager.update.manager", .args(["/usr/lib/pika/pikman-update-manager/scripts/apt_update", "fr_FR"])
) .status()
.unwrap(); .unwrap();
if instance.is_single() { match apt_update_command.code().unwrap() {
let current_locale = match std::env::var_os("LANG") { 0 => update_status_sender_clone0
Some(v) => v .send_blocking("FN_OVERRIDE_SUCCESSFUL".to_owned())
.into_string() .unwrap(),
53 => {}
_ => {
update_status_sender_clone0
.send_blocking(t!("update_status_error_perms").to_string())
.unwrap();
update_status_sender_clone0
.send_blocking("FN_OVERRIDE_FAILED".to_owned())
.unwrap() .unwrap()
.chars()
.take_while(|&ch| ch != '.')
.collect::<String>(),
None => panic!("$LANG is not set"),
};
let apt_update_command = Command::new("pkexec")
.args([
"/usr/lib/pika/pikman-update-manager/scripts/apt_update",
&current_locale,
])
.status()
.unwrap();
match apt_update_command.code().unwrap() {
0 => update_status_sender_clone0
.send_blocking("FN_OVERRIDE_SUCCESSFUL".to_owned())
.unwrap(),
53 => {}
_ => {
update_status_sender_clone0
.send_blocking(t!("update_status_error_perms").to_string())
.unwrap();
update_status_sender_clone0
.send_blocking("FN_OVERRIDE_FAILED".to_owned())
.unwrap()
}
} }
}; }
}); });
let main_box = Box::builder() let main_box = Box::builder()
@ -146,11 +128,11 @@ pub fn apt_update_page(
.build(); .build();
/*let packages_ignored_viewport_page = adw::StatusPage::builder() /*let packages_ignored_viewport_page = adw::StatusPage::builder()
.icon_name("dialog-warning-symbolic") .icon_name("dialog-warning-symbolic")
.title(t!("apt_ignored_viewport_page_title")) .title(t!("apt_ignored_viewport_page_title"))
.hexpand(true) .hexpand(true)
.vexpand(true) .vexpand(true)
.build();*/ .build();*/
let viewport_bin = adw::Bin::builder() let viewport_bin = adw::Bin::builder()
.child(&packages_no_viewport_page) .child(&packages_no_viewport_page)
@ -528,44 +510,51 @@ fn set_all_apt_row_marks_to(parent_listbox: &impl IsA<ListBox>, value: bool) {
fn get_apt_upgrades(get_upgradable_sender: &async_channel::Sender<AptPackageSocket>) { fn get_apt_upgrades(get_upgradable_sender: &async_channel::Sender<AptPackageSocket>) {
let get_upgradable_sender = get_upgradable_sender.clone(); let get_upgradable_sender = get_upgradable_sender.clone();
thread::spawn(move || { thread::spawn(move || {
// Create upgradable list cache // Create upgradable list cache
let upgradable_cache = new_cache!().unwrap(); let upgradable_cache = new_cache!().unwrap();
// //
upgradable_cache.upgrade(Upgrade::FullUpgrade).unwrap(); upgradable_cache.upgrade(Upgrade::FullUpgrade).unwrap();
upgradable_cache.resolve(true).unwrap(); upgradable_cache.resolve(true).unwrap();
let mut upgradeable_iter = upgradable_cache.get_changes(false).peekable(); let mut upgradeable_iter =
while let Some(pkg) = upgradeable_iter.next() { upgradable_cache.get_changes(false).peekable();
if !pkg.marked_delete() { while let Some(pkg) = upgradeable_iter.next() {
let candidate_version_pkg = pkg.candidate().unwrap(); if !pkg.marked_delete() {
let package_struct = AptPackageSocket { let candidate_version_pkg = pkg.candidate().unwrap();
name: pkg.name().to_string(), let package_struct = AptPackageSocket {
arch: pkg.arch().to_string(), name: pkg.name().to_string(),
installed_version: match pkg.installed() { arch: pkg.arch().to_string(),
Some(t) => t.version().to_string(), installed_version: match pkg.installed() {
_ => t!("installed_version_to_be_installed").to_string(), Some(t) => t.version().to_string(),
}, _ => {
candidate_version: candidate_version_pkg.version().to_string(), t!("installed_version_to_be_installed").to_string()
description: match candidate_version_pkg.description() { }
Some(s) => s, },
_ => t!("apt_pkg_property_unknown").to_string(), candidate_version: candidate_version_pkg
}, .version()
source_uri: candidate_version_pkg .to_string(),
.uris() description: match candidate_version_pkg.description() {
.collect::<Vec<String>>() Some(s) => s,
.join("\n"), _ => t!("apt_pkg_property_unknown").to_string(),
maintainer: match candidate_version_pkg.get_record(RecordField::Maintainer) { },
Some(s) => s, source_uri: candidate_version_pkg
_ => t!("apt_pkg_property_unknown").to_string(), .uris()
}, .collect::<Vec<String>>()
size: candidate_version_pkg.size(), .join("\n"),
installed_size: candidate_version_pkg.installed_size(), maintainer: match candidate_version_pkg
is_last: upgradeable_iter.peek().is_none(), .get_record(RecordField::Maintainer)
}; {
get_upgradable_sender.send_blocking(package_struct).unwrap() Some(s) => s,
} _ => t!("apt_pkg_property_unknown").to_string(),
} },
}); size: candidate_version_pkg.size(),
installed_size: candidate_version_pkg.installed_size(),
is_last: upgradeable_iter.peek().is_none(),
};
get_upgradable_sender.send_blocking(package_struct).unwrap()
}
}
});
} }

14
src/bin/gui/apt_update_page/process.rs
View File

@ -411,20 +411,8 @@ fn apt_full_upgrade_from_socket(
}); });
thread::spawn(move || { thread::spawn(move || {
let current_locale = match std::env::var_os("LANG") {
Some(v) => v
.into_string()
.unwrap()
.chars()
.take_while(|&ch| ch != '.')
.collect::<String>(),
None => panic!("$LANG is not set"),
};
let apt_upgrade_command = Command::new("pkexec") let apt_upgrade_command = Command::new("pkexec")
.args([ .args(["/usr/lib/pika/pikman-update-manager/scripts/apt_full_upgrade"])
"/usr/lib/pika/pikman-update-manager/scripts/apt_full_upgrade",
&current_locale,
])
.status() .status()
.unwrap(); .unwrap();
match apt_upgrade_command.code().unwrap() { match apt_upgrade_command.code().unwrap() {

21
src/bin/gui/build_ui/mod.rs
View File

@ -134,8 +134,8 @@ pub fn build_ui(app: &Application) {
update_sys_tray.connect_activate(clone!( update_sys_tray.connect_activate(clone!(
#[strong] #[strong]
tray_handle, tray_handle,
/*#[strong] #[strong]
refresh_button,*/ refresh_button,
move |_, param| { move |_, param| {
let array: &[i32] = param.unwrap().fixed_array().unwrap(); let array: &[i32] = param.unwrap().fixed_array().unwrap();
let vec = array.to_vec(); let vec = array.to_vec();
@ -175,7 +175,7 @@ pub fn build_ui(app: &Application) {
.unwrap(), .unwrap(),
); );
}); });
/*if apt_update_count == -1 || flatpak_update_count == -1 { if apt_update_count == -1 || flatpak_update_count == -1 {
refresh_button.set_sensitive(false); refresh_button.set_sensitive(false);
refresh_button.set_tooltip_text(Some( refresh_button.set_tooltip_text(Some(
&t!("pikman_indicator_flatpak_item_label_calculating").to_string(), &t!("pikman_indicator_flatpak_item_label_calculating").to_string(),
@ -184,7 +184,7 @@ pub fn build_ui(app: &Application) {
refresh_button.set_sensitive(true); refresh_button.set_sensitive(true);
refresh_button refresh_button
.set_tooltip_text(Some(&t!("refresh_button_tooltip_text").to_string())); .set_tooltip_text(Some(&t!("refresh_button_tooltip_text").to_string()));
}*/ }
} }
)); ));
update_sys_tray.activate(Some(&glib::Variant::array_from_fixed_array(&[-1, -1]))); update_sys_tray.activate(Some(&glib::Variant::array_from_fixed_array(&[-1, -1])));
@ -244,7 +244,7 @@ pub fn build_ui(app: &Application) {
let window_breakpoint = adw::Breakpoint::new(BreakpointCondition::new_length( let window_breakpoint = adw::Breakpoint::new(BreakpointCondition::new_length(
BreakpointConditionLengthType::MaxWidth, BreakpointConditionLengthType::MaxWidth,
1200.0, 1000.0,
LengthUnit::Sp, LengthUnit::Sp,
)); ));
@ -296,12 +296,12 @@ pub fn build_ui(app: &Application) {
.build(); .build();
let window_content_page_split_view = adw::OverlaySplitView::builder() let window_content_page_split_view = adw::OverlaySplitView::builder()
.vexpand(true)
.hexpand(true)
.content(&window_toolbar) .content(&window_toolbar)
.sidebar(&window_adw_view_switcher_sidebar_box) .sidebar(&window_adw_view_switcher_sidebar_box)
.max_sidebar_width(300.0) .max_sidebar_width(300.0)
.min_sidebar_width(290.0) .min_sidebar_width(300.0)
.sidebar_width_unit(adw::LengthUnit::Px)
.sidebar_width_fraction(0.2)
.enable_hide_gesture(true) .enable_hide_gesture(true)
.enable_show_gesture(true) .enable_show_gesture(true)
.build(); .build();
@ -338,7 +338,7 @@ pub fn build_ui(app: &Application) {
.default_width(glib_settings.int("window-width")) .default_width(glib_settings.int("window-width"))
.default_height(glib_settings.int("window-height")) .default_height(glib_settings.int("window-height"))
// //
.width_request(1000) .width_request(900)
.height_request(700) .height_request(700)
.content(&window_content_page_split_view) .content(&window_content_page_split_view)
// Startup // Startup
@ -664,8 +664,7 @@ pub fn build_ui(app: &Application) {
} }
} }
ConstantLoopMessage::RefreshRequest => { ConstantLoopMessage::RefreshRequest => {
update_sys_tray update_sys_tray.activate(Some(&glib::Variant::array_from_fixed_array(&[-1, -1])));
.activate(Some(&glib::Variant::array_from_fixed_array(&[-1, -1])));
apt_retry_signal_action.activate(None); apt_retry_signal_action.activate(None);
flatpak_retry_signal_action.activate(None); flatpak_retry_signal_action.activate(None);
} }

609
src/bin/gui/flatpak_update_page/mod.rs
View File

@ -193,11 +193,11 @@ pub fn flatpak_update_page(
.build(); .build();
/*let packages_ignored_viewport_page = adw::StatusPage::builder() /*let packages_ignored_viewport_page = adw::StatusPage::builder()
.icon_name("dialog-warning-symbolic") .icon_name("dialog-warning-symbolic")
.title(t!("flatpak_ignored_viewport_page_title")) .title(t!("flatpak_ignored_viewport_page_title"))
.hexpand(true) .hexpand(true)
.vexpand(true) .vexpand(true)
.build();*/ .build();*/
let viewport_bin = adw::Bin::builder() let viewport_bin = adw::Bin::builder()
.child(&packages_no_viewport_page) .child(&packages_no_viewport_page)
@ -529,296 +529,337 @@ fn get_flatpak_updates(
apt_update_count: &Rc<RefCell<i32>>, apt_update_count: &Rc<RefCell<i32>>,
flatpak_update_count: &Rc<RefCell<i32>>, flatpak_update_count: &Rc<RefCell<i32>>,
) { ) {
let flatpak_system_installation = libflatpak::Installation::new_system(cancellable_no).unwrap(); let flatpak_system_installation =
let flatpak_system_updates = flatpak_system_installation libflatpak::Installation::new_system(cancellable_no).unwrap();
.list_installed_refs_for_update(cancellable_no) let flatpak_system_updates = flatpak_system_installation
.unwrap(); .list_installed_refs_for_update(cancellable_no)
// .unwrap();
let flatpak_user_installation = libflatpak::Installation::new_user(cancellable_no).unwrap(); //
let flatpak_user_updates = flatpak_user_installation let flatpak_user_installation =
.list_installed_refs_for_update(cancellable_no) libflatpak::Installation::new_user(cancellable_no).unwrap();
.unwrap(); let flatpak_user_updates = flatpak_user_installation
// .list_installed_refs_for_update(cancellable_no)
let mut system_last_triggered = false; .unwrap();
let mut user_last_triggered = false; //
// let mut system_last_triggered = false;
if !flatpak_system_updates.is_empty() || !flatpak_user_updates.is_empty() { let mut user_last_triggered = false;
update_button.set_sensitive(true); //
viewport_bin.set_child(Some(packages_viewport)); if !flatpak_system_updates.is_empty() || !flatpak_user_updates.is_empty() {
} update_button.set_sensitive(true);
// viewport_bin.set_child(Some(packages_viewport));
if !flatpak_system_updates.is_empty() {
let flatpak_system_updates_iter = &mut flatpak_system_updates.iter().peekable();
//
while let Some(flatpak_ref) = flatpak_system_updates_iter.next() {
let mut remote_flatpak_ref: Option<libflatpak::RemoteRef> = None;
while let Ok(remotes) =
libflatpak::Installation::list_remotes(&flatpak_system_installation, cancellable_no)
{
for remote in remotes {
if remote.is_disabled() {
continue;
};
match libflatpak::Installation::fetch_remote_ref_sync(
&flatpak_system_installation,
&match remote.name() {
Some(t) => t,
None => continue,
},
flatpak_ref.kind(),
&match flatpak_ref.name() {
Some(t) => t,
None => continue,
},
flatpak_ref.arch().as_deref(),
flatpak_ref.branch().as_deref(),
cancellable_no,
) {
Ok(t) => {
remote_flatpak_ref = Some(t);
break;
} }
Err(_) => continue, //
} if !flatpak_system_updates.is_empty() {
} let flatpak_system_updates_iter =
if remote_flatpak_ref.is_some() { &mut flatpak_system_updates.iter().peekable();
break; //
} while let Some(flatpak_ref) = flatpak_system_updates_iter.next() {
} let mut remote_flatpak_ref: Option<libflatpak::RemoteRef> = None;
let flatref_struct = FlatpakRefStruct { while let Ok(remotes) = libflatpak::Installation::list_remotes(
ref_name: flatpak_ref.name().unwrap_or("Unknown".into()).to_string(), &flatpak_system_installation,
name: flatpak_ref cancellable_no,
.appdata_name() ) {
.unwrap_or(flatpak_ref.name().unwrap_or("Unknown".into())) for remote in remotes {
.to_string(), if remote.is_disabled() {
arch: flatpak_ref continue;
.arch() };
.unwrap_or("Unknown Arch".into()) match libflatpak::Installation::fetch_remote_ref_sync(
.to_string(), &flatpak_system_installation,
summary: flatpak_ref &match remote.name() {
.appdata_summary() Some(t) => t,
.unwrap_or("No Summary".into()) None => continue,
.to_string(), },
remote_name: match remote_flatpak_ref { flatpak_ref.kind(),
Some(ref t) => t.remote_name().unwrap_or("Unknown".into()).to_string(), &match flatpak_ref.name() {
None => "Unknown".into(), Some(t) => t,
}, None => continue,
installed_size_installed: flatpak_ref.installed_size(), },
installed_size_remote: match remote_flatpak_ref { flatpak_ref.arch().as_deref(),
Some(ref t) => t.installed_size(), flatpak_ref.branch().as_deref(),
None => 0, cancellable_no,
}, ) {
download_size: match remote_flatpak_ref { Ok(t) => {
Some(t) => t.download_size(), remote_flatpak_ref = Some(t);
None => 0, break;
}, }
ref_format: flatpak_ref.format_ref().unwrap().into(), Err(_) => continue,
is_system: true, }
is_last: flatpak_system_updates_iter.peek().is_none(), }
}; if remote_flatpak_ref.is_some() {
break;
}
}
let flatref_struct = FlatpakRefStruct {
ref_name: flatpak_ref
.name()
.unwrap_or("Unknown".into())
.to_string(),
name: flatpak_ref
.appdata_name()
.unwrap_or(flatpak_ref.name().unwrap_or("Unknown".into()))
.to_string(),
arch: flatpak_ref
.arch()
.unwrap_or("Unknown Arch".into())
.to_string(),
summary: flatpak_ref
.appdata_summary()
.unwrap_or("No Summary".into())
.to_string(),
remote_name: match remote_flatpak_ref {
Some(ref t) => {
t.remote_name().unwrap_or("Unknown".into()).to_string()
}
None => "Unknown".into(),
},
installed_size_installed: flatpak_ref.installed_size(),
installed_size_remote: match remote_flatpak_ref {
Some(ref t) => t.installed_size(),
None => 0,
},
download_size: match remote_flatpak_ref {
Some(t) => t.download_size(),
None => 0,
},
ref_format: flatpak_ref.format_ref().unwrap().into(),
is_system: true,
is_last: flatpak_system_updates_iter.peek().is_none(),
};
let flatpak_row = FlatpakRefRow::new(&flatref_struct); let flatpak_row = FlatpakRefRow::new(&flatref_struct);
system_refs_for_upgrade_vec system_refs_for_upgrade_vec
.borrow_mut() .borrow_mut()
.push(flatpak_row.clone()); .push(flatpak_row.clone());
system_refs_for_upgrade_vec_all system_refs_for_upgrade_vec_all
.borrow_mut() .borrow_mut()
.push(flatpak_row.clone()); .push(flatpak_row.clone());
flatpak_row.connect_closure( flatpak_row.connect_closure(
"checkbutton-toggled", "checkbutton-toggled",
false, false,
closure_local!( closure_local!(
#[strong] #[strong]
select_button, select_button,
#[strong] #[strong]
update_button, update_button,
#[strong] #[strong]
packages_boxedlist, packages_boxedlist,
#[strong] #[strong]
system_refs_for_upgrade_vec, system_refs_for_upgrade_vec,
move |flatpak_row: FlatpakRefRow| { move |flatpak_row: FlatpakRefRow| {
if is_widget_select_all_ready(&packages_boxedlist) { if is_widget_select_all_ready(&packages_boxedlist) {
select_button.set_label(&t!("select_button_select_all").to_string()); select_button.set_label(
&t!("select_button_select_all").to_string(),
);
} else {
select_button.set_label(
&t!("select_button_deselect_all").to_string(),
);
}
update_button.set_sensitive(!is_all_children_unmarked(
&packages_boxedlist,
));
system_refs_for_upgrade_vec
.borrow_mut()
.push(flatpak_row);
}
),
);
flatpak_row.connect_closure(
"checkbutton-untoggled",
false,
closure_local!(
#[strong]
select_button,
#[strong]
update_button,
#[strong]
packages_boxedlist,
#[strong]
system_refs_for_upgrade_vec,
move |flatpak_row: FlatpakRefRow| {
select_button.set_label(
&t!("select_button_select_all").to_string(),
);
update_button.set_sensitive(!is_all_children_unmarked(
&packages_boxedlist,
));
system_refs_for_upgrade_vec.borrow_mut().retain(|x| {
x.flatref_ref_format()
!= flatpak_row.flatref_ref_format()
});
}
),
);
packages_boxedlist.append(&flatpak_row);
(*flatpak_update_count.borrow_mut() += 1);
if flatref_struct.is_system && flatref_struct.is_last {
system_last_triggered = true
}
}
} else { } else {
select_button.set_label(&t!("select_button_deselect_all").to_string()); system_last_triggered = true
} }
update_button.set_sensitive(!is_all_children_unmarked(&packages_boxedlist)); if !flatpak_user_updates.is_empty() {
system_refs_for_upgrade_vec.borrow_mut().push(flatpak_row); let flatpak_user_updates_iter =
} &mut flatpak_user_updates.iter().peekable();
), //
); while let Some(flatpak_ref) = flatpak_user_updates_iter.next() {
flatpak_row.connect_closure( let mut remote_flatpak_ref: Option<libflatpak::RemoteRef> = None;
"checkbutton-untoggled", while let Ok(remotes) = libflatpak::Installation::list_remotes(
false, &flatpak_user_installation,
closure_local!( cancellable_no,
#[strong] ) {
select_button, for remote in remotes {
#[strong] if remote.is_disabled() {
update_button, continue;
#[strong] };
packages_boxedlist, match libflatpak::Installation::fetch_remote_ref_sync(
#[strong] &flatpak_user_installation,
system_refs_for_upgrade_vec, &match remote.name() {
move |flatpak_row: FlatpakRefRow| { Some(t) => t,
select_button.set_label(&t!("select_button_select_all").to_string()); None => continue,
update_button.set_sensitive(!is_all_children_unmarked(&packages_boxedlist)); },
system_refs_for_upgrade_vec flatpak_ref.kind(),
.borrow_mut() &match flatpak_ref.name() {
.retain(|x| x.flatref_ref_format() != flatpak_row.flatref_ref_format()); Some(t) => t,
} None => continue,
), },
); flatpak_ref.arch().as_deref(),
flatpak_ref.branch().as_deref(),
cancellable_no,
) {
Ok(t) => {
remote_flatpak_ref = Some(t);
break;
}
Err(_) => continue,
}
}
if remote_flatpak_ref.is_some() {
break;
}
}
let flatref_struct = FlatpakRefStruct {
ref_name: flatpak_ref
.name()
.unwrap_or("Unknown".into())
.to_string(),
name: flatpak_ref
.appdata_name()
.unwrap_or(flatpak_ref.name().unwrap_or("Unknown".into()))
.to_string(),
arch: flatpak_ref
.arch()
.unwrap_or("Unknown Arch".into())
.to_string(),
summary: flatpak_ref
.appdata_summary()
.unwrap_or("No Summary".into())
.to_string(),
remote_name: match remote_flatpak_ref {
Some(ref t) => {
t.remote_name().unwrap_or("Unknown".into()).to_string()
}
None => "Unknown".into(),
},
installed_size_installed: flatpak_ref.installed_size(),
installed_size_remote: match remote_flatpak_ref {
Some(ref t) => t.installed_size(),
None => 0,
},
download_size: match remote_flatpak_ref {
Some(t) => t.download_size(),
None => 0,
},
ref_format: flatpak_ref.format_ref().unwrap().into(),
is_system: false,
is_last: flatpak_user_updates_iter.peek().is_none(),
};
packages_boxedlist.append(&flatpak_row); let flatpak_row = FlatpakRefRow::new(&flatref_struct);
(*flatpak_update_count.borrow_mut() += 1);
if flatref_struct.is_system && flatref_struct.is_last {
system_last_triggered = true
}
}
} else {
system_last_triggered = true
}
if !flatpak_user_updates.is_empty() {
let flatpak_user_updates_iter = &mut flatpak_user_updates.iter().peekable();
//
while let Some(flatpak_ref) = flatpak_user_updates_iter.next() {
let mut remote_flatpak_ref: Option<libflatpak::RemoteRef> = None;
while let Ok(remotes) =
libflatpak::Installation::list_remotes(&flatpak_user_installation, cancellable_no)
{
for remote in remotes {
if remote.is_disabled() {
continue;
};
match libflatpak::Installation::fetch_remote_ref_sync(
&flatpak_user_installation,
&match remote.name() {
Some(t) => t,
None => continue,
},
flatpak_ref.kind(),
&match flatpak_ref.name() {
Some(t) => t,
None => continue,
},
flatpak_ref.arch().as_deref(),
flatpak_ref.branch().as_deref(),
cancellable_no,
) {
Ok(t) => {
remote_flatpak_ref = Some(t);
break;
}
Err(_) => continue,
}
}
if remote_flatpak_ref.is_some() {
break;
}
}
let flatref_struct = FlatpakRefStruct {
ref_name: flatpak_ref.name().unwrap_or("Unknown".into()).to_string(),
name: flatpak_ref
.appdata_name()
.unwrap_or(flatpak_ref.name().unwrap_or("Unknown".into()))
.to_string(),
arch: flatpak_ref
.arch()
.unwrap_or("Unknown Arch".into())
.to_string(),
summary: flatpak_ref
.appdata_summary()
.unwrap_or("No Summary".into())
.to_string(),
remote_name: match remote_flatpak_ref {
Some(ref t) => t.remote_name().unwrap_or("Unknown".into()).to_string(),
None => "Unknown".into(),
},
installed_size_installed: flatpak_ref.installed_size(),
installed_size_remote: match remote_flatpak_ref {
Some(ref t) => t.installed_size(),
None => 0,
},
download_size: match remote_flatpak_ref {
Some(t) => t.download_size(),
None => 0,
},
ref_format: flatpak_ref.format_ref().unwrap().into(),
is_system: false,
is_last: flatpak_user_updates_iter.peek().is_none(),
};
let flatpak_row = FlatpakRefRow::new(&flatref_struct); user_refs_for_upgrade_vec
.borrow_mut()
.push(flatpak_row.clone());
user_refs_for_upgrade_vec user_refs_for_upgrade_vec_all
.borrow_mut() .borrow_mut()
.push(flatpak_row.clone()); .push(flatpak_row.clone());
user_refs_for_upgrade_vec_all flatpak_row.connect_closure(
.borrow_mut() "checkbutton-toggled",
.push(flatpak_row.clone()); false,
closure_local!(
flatpak_row.connect_closure( #[strong]
"checkbutton-toggled", select_button,
false, #[strong]
closure_local!( update_button,
#[strong] #[strong]
select_button, packages_boxedlist,
#[strong] #[strong]
update_button, user_refs_for_upgrade_vec,
#[strong] move |flatpak_row: FlatpakRefRow| {
packages_boxedlist, if is_widget_select_all_ready(&packages_boxedlist) {
#[strong] select_button.set_label(
user_refs_for_upgrade_vec, &t!("select_button_select_all").to_string(),
move |flatpak_row: FlatpakRefRow| { );
if is_widget_select_all_ready(&packages_boxedlist) { } else {
select_button.set_label(&t!("select_button_select_all").to_string()); select_button.set_label(
&t!("select_button_deselect_all").to_string(),
);
}
update_button.set_sensitive(!is_all_children_unmarked(
&packages_boxedlist,
));
user_refs_for_upgrade_vec
.borrow_mut()
.push(flatpak_row);
}
),
);
flatpak_row.connect_closure(
"checkbutton-untoggled",
false,
closure_local!(
#[strong]
select_button,
#[strong]
update_button,
#[strong]
packages_boxedlist,
#[strong]
user_refs_for_upgrade_vec,
move |flatpak_row: FlatpakRefRow| {
select_button.set_label(
&t!("select_button_select_all").to_string(),
);
update_button.set_sensitive(!is_all_children_unmarked(
&packages_boxedlist,
));
user_refs_for_upgrade_vec.borrow_mut().retain(|x| {
x.flatref_ref_format()
!= flatpak_row.flatref_ref_format()
});
}
),
);
packages_boxedlist.append(&flatpak_row);
(*flatpak_update_count.borrow_mut() += 1);
if !flatref_struct.is_system && flatref_struct.is_last {
user_last_triggered = true
}
}
} else { } else {
select_button.set_label(&t!("select_button_deselect_all").to_string()); user_last_triggered = true
}
if user_last_triggered && system_last_triggered {
packages_boxedlist.set_sensitive(true);
update_sys_tray.activate(Some(&glib::Variant::array_from_fixed_array(
&[*apt_update_count.borrow(), *flatpak_update_count.borrow()],
)));
} }
update_button.set_sensitive(!is_all_children_unmarked(&packages_boxedlist));
user_refs_for_upgrade_vec.borrow_mut().push(flatpak_row);
}
),
);
flatpak_row.connect_closure(
"checkbutton-untoggled",
false,
closure_local!(
#[strong]
select_button,
#[strong]
update_button,
#[strong]
packages_boxedlist,
#[strong]
user_refs_for_upgrade_vec,
move |flatpak_row: FlatpakRefRow| {
select_button.set_label(&t!("select_button_select_all").to_string());
update_button.set_sensitive(!is_all_children_unmarked(&packages_boxedlist));
user_refs_for_upgrade_vec
.borrow_mut()
.retain(|x| x.flatref_ref_format() != flatpak_row.flatref_ref_format());
}
),
);
packages_boxedlist.append(&flatpak_row);
(*flatpak_update_count.borrow_mut() += 1);
if !flatref_struct.is_system && flatref_struct.is_last {
user_last_triggered = true
}
}
} else {
user_last_triggered = true
}
if user_last_triggered && system_last_triggered {
packages_boxedlist.set_sensitive(true);
update_sys_tray.activate(Some(&glib::Variant::array_from_fixed_array(&[
*apt_update_count.borrow(),
*flatpak_update_count.borrow(),
])));
}
} }

8
src/lib/apt_install_progress_socket/mod.rs
View File

@ -8,16 +8,12 @@ use tokio::runtime::Runtime;
pub struct AptInstallProgressSocket<'a> { pub struct AptInstallProgressSocket<'a> {
percent_socket_path: &'a str, percent_socket_path: &'a str,
status_socket_path: &'a str, status_socket_path: &'a str,
error_strfmt_trans_str: String, error_strfmt_trans_str: &'a str,
} }
impl<'a> AptInstallProgressSocket<'a> { impl<'a> AptInstallProgressSocket<'a> {
/// Returns a new default progress instance. /// Returns a new default progress instance.
pub fn new( pub fn new(percent_socket_path: &'a str, status_socket_path: &'a str, error_strfmt_trans_str: &'a str) -> Self {
percent_socket_path: &'a str,
status_socket_path: &'a str,
error_strfmt_trans_str: String,
) -> Self {
let progress = Self { let progress = Self {
percent_socket_path: percent_socket_path, percent_socket_path: percent_socket_path,
status_socket_path: status_socket_path, status_socket_path: status_socket_path,

9
src/lib/apt_update_progress_socket/mod.rs
View File

@ -18,14 +18,7 @@ pub struct AptUpdateProgressSocket<'a> {
impl<'a> AptUpdateProgressSocket<'a> { impl<'a> AptUpdateProgressSocket<'a> {
/// Returns a new default progress instance. /// Returns a new default progress instance.
pub fn new( pub fn new(percent_socket_path: &'a str, status_socket_path: &'a str, hit_strfmt_trans_str: &'a str, fetch_strfmt_trans_str: &'a str, done_strfmt_trans_str: &'a str, fail_strfmt_trans_str: &'a str) -> Self {
percent_socket_path: &'a str,
status_socket_path: &'a str,
hit_strfmt_trans_str: &'a str,
fetch_strfmt_trans_str: &'a str,
done_strfmt_trans_str: &'a str,
fail_strfmt_trans_str: &'a str,
) -> Self {
let progress = Self { let progress = Self {
pulse_interval: 0, pulse_interval: 0,
percent_socket_path: percent_socket_path, percent_socket_path: percent_socket_path,