vh/termscp
1
0
Fork 0
mirror of https://github.com/veeso/termscp.git synced 2026-03-31 23:32:20 -07:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

fix: replace assert! calls in UI activities with graceful error handling

Browse Source
This commit is contained in:
Christian Visintin
2026-02-27 22:27:14 +01:00
parent be237c39a6
commit 4fdaf82314
9 changed files with 1622 additions and 1759 deletions
Download Patch File Download Diff File Expand all files Collapse all files

961
src/ui/activities/auth/update.rs
View File

File diff suppressed because it is too large Load Diff

914
src/ui/activities/auth/view.rs
View File

File diff suppressed because it is too large Load Diff

8
src/ui/activities/setup/actions.rs
View File

@@ -135,7 +135,9 @@ impl SetupActivity {
error!("Could not leave alternate screen: {}", err);
}
// Lock ports
assert!(self.app.lock_ports().is_ok());
if let Err(err) = self.app.lock_ports() {
error!("Failed to lock ports: {err}");
}
// Write key to file
let res = match edit::edit(placeholder.as_bytes()) {
Ok(rsa_key) => {
@@ -168,7 +170,9 @@ impl SetupActivity {
error!("Could not clear screen screen: {}", err);
}
// Unlock ports
assert!(self.app.unlock_ports().is_ok());
if let Err(err) = self.app.unlock_ports() {
error!("Failed to unlock ports: {err}");
}
}
res

8
src/ui/activities/setup/config.rs
View File

@@ -71,7 +71,9 @@ impl SetupActivity {
error!("Could not leave alternate screen: {}", err);
}
// Lock ports
assert!(self.app.lock_ports().is_ok());
if let Err(err) = self.app.lock_ports() {
error!("Failed to lock ports: {err}");
}
// Get result
let result: Result<(), String> = match ctx.config().iter_ssh_keys().nth(idx) {
Some(key) => {
@@ -100,7 +102,9 @@ impl SetupActivity {
error!("Failed to enter raw mode: {}", err);
}
// Unlock ports
assert!(self.app.unlock_ports().is_ok());
if let Err(err) = self.app.unlock_ports() {
error!("Failed to unlock ports: {err}");
}
// Return result
result
}

414
src/ui/activities/setup/update.rs
View File

@@ -103,110 +103,120 @@ impl SetupActivity {
fn config_update(&mut self, msg: ConfigMsg) -> Option<Msg> {
match msg {
ConfigMsg::CheckUpdatesBlurDown => {
assert!(
self.app
.active(&Id::Config(IdConfig::PromptOnFileReplace))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Config(IdConfig::PromptOnFileReplace)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::CheckUpdatesBlurUp => {
assert!(self.app.active(&Id::Config(IdConfig::HiddenFiles)).is_ok());
if let Err(err) = self.app.active(&Id::Config(IdConfig::HiddenFiles)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::DefaultProtocolBlurDown => {
assert!(self.app.active(&Id::Config(IdConfig::HiddenFiles)).is_ok());
if let Err(err) = self.app.active(&Id::Config(IdConfig::HiddenFiles)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::DefaultProtocolBlurUp => {
assert!(self.app.active(&Id::Config(IdConfig::TextEditor)).is_ok());
if let Err(err) = self.app.active(&Id::Config(IdConfig::TextEditor)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::GroupDirsBlurDown => {
assert!(self.app.active(&Id::Config(IdConfig::LocalFileFmt)).is_ok());
if let Err(err) = self.app.active(&Id::Config(IdConfig::LocalFileFmt)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::GroupDirsBlurUp => {
assert!(
self.app
.active(&Id::Config(IdConfig::PromptOnFileReplace))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Config(IdConfig::PromptOnFileReplace)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::HiddenFilesBlurDown => {
assert!(self.app.active(&Id::Config(IdConfig::CheckUpdates)).is_ok());
if let Err(err) = self.app.active(&Id::Config(IdConfig::CheckUpdates)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::HiddenFilesBlurUp => {
assert!(
self.app
.active(&Id::Config(IdConfig::DefaultProtocol))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Config(IdConfig::DefaultProtocol)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::LocalFileFmtBlurDown => {
assert!(
self.app
.active(&Id::Config(IdConfig::RemoteFileFmt))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Config(IdConfig::RemoteFileFmt)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::LocalFileFmtBlurUp => {
assert!(self.app.active(&Id::Config(IdConfig::GroupDirs)).is_ok());
if let Err(err) = self.app.active(&Id::Config(IdConfig::GroupDirs)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::NotificationsEnabledBlurDown => {
assert!(
self.app
.active(&Id::Config(IdConfig::NotificationsThreshold))
.is_ok()
);
if let Err(err) = self
.app
.active(&Id::Config(IdConfig::NotificationsThreshold))
{
error!("Failed to activate component: {err}");
}
}
ConfigMsg::NotificationsEnabledBlurUp => {
assert!(
self.app
.active(&Id::Config(IdConfig::RemoteFileFmt))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Config(IdConfig::RemoteFileFmt)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::NotificationsThresholdBlurDown => {
assert!(self.app.active(&Id::Config(IdConfig::SshConfig)).is_ok());
if let Err(err) = self.app.active(&Id::Config(IdConfig::SshConfig)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::NotificationsThresholdBlurUp => {
assert!(
self.app
.active(&Id::Config(IdConfig::NotificationsEnabled))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Config(IdConfig::NotificationsEnabled)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::PromptOnFileReplaceBlurDown => {
assert!(self.app.active(&Id::Config(IdConfig::GroupDirs)).is_ok());
if let Err(err) = self.app.active(&Id::Config(IdConfig::GroupDirs)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::PromptOnFileReplaceBlurUp => {
assert!(self.app.active(&Id::Config(IdConfig::CheckUpdates)).is_ok());
if let Err(err) = self.app.active(&Id::Config(IdConfig::CheckUpdates)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::RemoteFileFmtBlurDown => {
assert!(
self.app
.active(&Id::Config(IdConfig::NotificationsEnabled))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Config(IdConfig::NotificationsEnabled)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::RemoteFileFmtBlurUp => {
assert!(self.app.active(&Id::Config(IdConfig::LocalFileFmt)).is_ok());
if let Err(err) = self.app.active(&Id::Config(IdConfig::LocalFileFmt)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::TextEditorBlurDown => {
assert!(
self.app
.active(&Id::Config(IdConfig::DefaultProtocol))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Config(IdConfig::DefaultProtocol)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::TextEditorBlurUp => {
assert!(self.app.active(&Id::Config(IdConfig::SshConfig)).is_ok());
if let Err(err) = self.app.active(&Id::Config(IdConfig::SshConfig)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::SshConfigBlurDown => {
assert!(self.app.active(&Id::Config(IdConfig::TextEditor)).is_ok());
if let Err(err) = self.app.active(&Id::Config(IdConfig::TextEditor)) {
error!("Failed to activate component: {err}");
}
}
ConfigMsg::SshConfigBlurUp => {
assert!(
self.app
.active(&Id::Config(IdConfig::NotificationsThreshold))
.is_ok()
);
if let Err(err) = self
.app
.active(&Id::Config(IdConfig::NotificationsThreshold))
{
error!("Failed to activate component: {err}");
}
}
ConfigMsg::ConfigChanged => {
self.set_config_changed(true);
@@ -251,10 +261,14 @@ impl SetupActivity {
self.mount_new_ssh_key();
}
SshMsg::SshHostBlur => {
assert!(self.app.active(&Id::Ssh(IdSsh::SshUsername)).is_ok());
if let Err(err) = self.app.active(&Id::Ssh(IdSsh::SshUsername)) {
error!("Failed to activate component: {err}");
}
}
SshMsg::SshUsernameBlur => {
assert!(self.app.active(&Id::Ssh(IdSsh::SshHost)).is_ok());
if let Err(err) = self.app.active(&Id::Ssh(IdSsh::SshHost)) {
error!("Failed to activate component: {err}");
}
}
}
None
@@ -263,222 +277,274 @@ impl SetupActivity {
fn theme_update(&mut self, msg: ThemeMsg) -> Option<Msg> {
match msg {
ThemeMsg::AuthAddressBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::AuthPort)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::AuthPort)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::AuthAddressBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::AuthProtocol)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::AuthProtocol)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::AuthBookmarksBlurDown => {
assert!(
self.app
.active(&Id::Theme(IdTheme::AuthRecentHosts))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Theme(IdTheme::AuthRecentHosts)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::AuthBookmarksBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::AuthPassword)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::AuthPassword)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::AuthPasswordBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::AuthBookmarks)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::AuthBookmarks)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::AuthPasswordBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::AuthUsername)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::AuthUsername)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::AuthPortBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::AuthUsername)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::AuthUsername)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::AuthPortBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::AuthAddress)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::AuthAddress)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::AuthProtocolBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::AuthAddress)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::AuthAddress)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::AuthProtocolBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::StatusSync)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::StatusSync)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::AuthRecentHostsBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::MiscError)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::MiscError)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::AuthRecentHostsBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::AuthBookmarks)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::AuthBookmarks)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::AuthUsernameBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::AuthPassword)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::AuthPassword)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::AuthUsernameBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::AuthPort)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::AuthPort)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::MiscErrorBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::MiscInfo)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::MiscInfo)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::MiscErrorBlurUp => {
assert!(
self.app
.active(&Id::Theme(IdTheme::AuthRecentHosts))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Theme(IdTheme::AuthRecentHosts)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::MiscInfoBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::MiscInput)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::MiscInput)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::MiscInfoBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::MiscError)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::MiscError)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::MiscInputBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::MiscKeys)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::MiscKeys)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::MiscInputBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::MiscInfo)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::MiscInfo)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::MiscKeysBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::MiscQuit)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::MiscQuit)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::MiscKeysBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::MiscInput)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::MiscInput)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::MiscQuitBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::MiscSave)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::MiscSave)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::MiscQuitBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::MiscKeys)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::MiscKeys)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::MiscSaveBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::MiscWarn)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::MiscWarn)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::MiscSaveBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::MiscQuit)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::MiscQuit)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::MiscWarnBlurDown => {
assert!(
self.app
.active(&Id::Theme(IdTheme::ExplorerLocalBg))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ExplorerLocalBg)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::MiscWarnBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::MiscSave)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::MiscSave)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ExplorerLocalBgBlurDown => {
assert!(
self.app
.active(&Id::Theme(IdTheme::ExplorerLocalFg))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ExplorerLocalFg)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ExplorerLocalBgBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::MiscWarn)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::MiscWarn)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ExplorerLocalFgBlurDown => {
assert!(
self.app
.active(&Id::Theme(IdTheme::ExplorerLocalHg))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ExplorerLocalHg)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ExplorerLocalFgBlurUp => {
assert!(
self.app
.active(&Id::Theme(IdTheme::ExplorerLocalBg))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ExplorerLocalBg)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ExplorerLocalHgBlurDown => {
assert!(
self.app
.active(&Id::Theme(IdTheme::ExplorerRemoteBg))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ExplorerRemoteBg)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ExplorerLocalHgBlurUp => {
assert!(
self.app
.active(&Id::Theme(IdTheme::ExplorerLocalFg))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ExplorerLocalFg)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ExplorerRemoteBgBlurDown => {
assert!(
self.app
.active(&Id::Theme(IdTheme::ExplorerRemoteFg))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ExplorerRemoteFg)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ExplorerRemoteBgBlurUp => {
assert!(
self.app
.active(&Id::Theme(IdTheme::ExplorerLocalHg))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ExplorerLocalHg)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ExplorerRemoteFgBlurDown => {
assert!(
self.app
.active(&Id::Theme(IdTheme::ExplorerRemoteHg))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ExplorerRemoteHg)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ExplorerRemoteFgBlurUp => {
assert!(
self.app
.active(&Id::Theme(IdTheme::ExplorerRemoteBg))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ExplorerRemoteBg)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ExplorerRemoteHgBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::ProgBarFull)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ProgBarFull)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ExplorerRemoteHgBlurUp => {
assert!(
self.app
.active(&Id::Theme(IdTheme::ExplorerRemoteFg))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ExplorerRemoteFg)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ProgBarFullBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::ProgBarPartial)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ProgBarPartial)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ProgBarFullBlurUp => {
assert!(
self.app
.active(&Id::Theme(IdTheme::ExplorerRemoteHg))
.is_ok()
);
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ExplorerRemoteHg)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ProgBarPartialBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::LogBg)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::LogBg)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ProgBarPartialBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::ProgBarFull)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ProgBarFull)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::LogBgBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::LogWindow)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::LogWindow)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::LogBgBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::ProgBarPartial)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::ProgBarPartial)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::LogWindowBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::StatusSorting)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::StatusSorting)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::LogWindowBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::LogBg)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::LogBg)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::StatusSortingBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::StatusHidden)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::StatusHidden)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::StatusSortingBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::LogWindow)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::LogWindow)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::StatusHiddenBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::StatusSync)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::StatusSync)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::StatusHiddenBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::StatusSorting)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::StatusSorting)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::StatusSyncBlurDown => {
assert!(self.app.active(&Id::Theme(IdTheme::AuthProtocol)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::AuthProtocol)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::StatusSyncBlurUp => {
assert!(self.app.active(&Id::Theme(IdTheme::StatusHidden)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::StatusHidden)) {
error!("Failed to activate component: {err}");
}
}
ThemeMsg::ColorChanged(id, color) => {
self.action_save_color(id, color);

244
src/ui/activities/setup/view/mod.rs
View File

@@ -40,16 +40,16 @@ impl SetupActivity {
/// Mount error box
pub(super) fn mount_error<S: AsRef<str>>(&mut self, text: S) {
assert!(
self.app
.remount(
Id::Common(IdCommon::ErrorPopup),
Box::new(components::ErrorPopup::new(text)),
vec![],
)
.is_ok()
);
assert!(self.app.active(&Id::Common(IdCommon::ErrorPopup)).is_ok());
if let Err(err) = self.app.remount(
Id::Common(IdCommon::ErrorPopup),
Box::new(components::ErrorPopup::new(text)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.active(&Id::Common(IdCommon::ErrorPopup)) {
error!("Failed to activate component: {err}");
}
}
/// Umount error message
@@ -59,16 +59,16 @@ impl SetupActivity {
/// Mount quit popup
pub(super) fn mount_quit(&mut self) {
assert!(
self.app
.remount(
Id::Common(IdCommon::QuitPopup),
Box::<components::QuitPopup>::default(),
vec![],
)
.is_ok()
);
assert!(self.app.active(&Id::Common(IdCommon::QuitPopup)).is_ok());
if let Err(err) = self.app.remount(
Id::Common(IdCommon::QuitPopup),
Box::<components::QuitPopup>::default(),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.active(&Id::Common(IdCommon::QuitPopup)) {
error!("Failed to activate component: {err}");
}
}
/// Umount quit
@@ -78,16 +78,16 @@ impl SetupActivity {
/// Mount save popup
pub(super) fn mount_save_popup(&mut self) {
assert!(
self.app
.remount(
Id::Common(IdCommon::SavePopup),
Box::<components::SavePopup>::default(),
vec![],
)
.is_ok()
);
assert!(self.app.active(&Id::Common(IdCommon::SavePopup)).is_ok());
if let Err(err) = self.app.remount(
Id::Common(IdCommon::SavePopup),
Box::<components::SavePopup>::default(),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.active(&Id::Common(IdCommon::SavePopup)) {
error!("Failed to activate component: {err}");
}
}
/// Umount quit
@@ -97,16 +97,16 @@ impl SetupActivity {
/// Mount help
pub(super) fn mount_help(&mut self) {
assert!(
self.app
.remount(
Id::Common(IdCommon::Keybindings),
Box::<components::Keybindings>::default(),
vec![],
)
.is_ok()
);
assert!(self.app.active(&Id::Common(IdCommon::Keybindings)).is_ok());
if let Err(err) = self.app.remount(
Id::Common(IdCommon::Keybindings),
Box::<components::Keybindings>::default(),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.active(&Id::Common(IdCommon::Keybindings)) {
error!("Failed to activate component: {err}");
}
}
/// Umount help
@@ -148,96 +148,90 @@ impl SetupActivity {
/// Mount common components
fn mount_commons(&mut self, layout: ViewLayout) {
// Radio tab
assert!(
self.app
.remount(
Id::Common(IdCommon::Header),
Box::new(components::Header::new(layout)),
vec![],
)
.is_ok()
);
if let Err(err) = self.app.remount(
Id::Common(IdCommon::Header),
Box::new(components::Header::new(layout)),
vec![],
) {
error!("Failed to remount component: {err}");
}
// Footer
assert!(
self.app
.remount(
Id::Common(IdCommon::Footer),
Box::<components::Footer>::default(),
vec![],
)
.is_ok()
);
if let Err(err) = self.app.remount(
Id::Common(IdCommon::Footer),
Box::<components::Footer>::default(),
vec![],
) {
error!("Failed to remount component: {err}");
}
}
/// Mount global listener
fn mount_global_listener(&mut self) {
assert!(
self.app
.mount(
Id::Common(IdCommon::GlobalListener),
Box::<components::GlobalListener>::default(),
vec![
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Esc,
modifiers: KeyModifiers::NONE,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Function(10),
modifiers: KeyModifiers::NONE,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Tab,
modifiers: KeyModifiers::NONE,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Char('h'),
modifiers: KeyModifiers::CONTROL,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Function(1),
modifiers: KeyModifiers::NONE,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Char('r'),
modifiers: KeyModifiers::CONTROL,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Char('s'),
modifiers: KeyModifiers::CONTROL,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Function(4),
modifiers: KeyModifiers::NONE,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(SubEventClause::WindowResize, SubClause::Always)
]
)
.is_ok()
);
if let Err(err) = self.app.mount(
Id::Common(IdCommon::GlobalListener),
Box::<components::GlobalListener>::default(),
vec![
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Esc,
modifiers: KeyModifiers::NONE,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Function(10),
modifiers: KeyModifiers::NONE,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Tab,
modifiers: KeyModifiers::NONE,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Char('h'),
modifiers: KeyModifiers::CONTROL,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Function(1),
modifiers: KeyModifiers::NONE,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Char('r'),
modifiers: KeyModifiers::CONTROL,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Char('s'),
modifiers: KeyModifiers::CONTROL,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(
SubEventClause::Keyboard(KeyEvent {
code: Key::Function(4),
modifiers: KeyModifiers::NONE,
}),
Self::no_popup_mounted_clause(),
),
Sub::new(SubEventClause::WindowResize, SubClause::Always),
],
) {
error!("Failed to mount component: {err}");
}
}
/// Returns a sub clause which requires that no popup is mounted in order to be satisfied

216
src/ui/activities/setup/view/setup.rs
View File

@@ -32,7 +32,9 @@ impl SetupActivity {
// Load values
self.load_input_values();
// Active text editor
assert!(self.app.active(&Id::Config(IdConfig::TextEditor)).is_ok());
if let Err(err) = self.app.active(&Id::Config(IdConfig::TextEditor)) {
error!("Failed to activate component: {err}");
}
}
pub(super) fn view_setup(&mut self) {
@@ -145,133 +147,111 @@ impl SetupActivity {
// Text editor
let text_editor: String =
String::from(self.config().get_text_editor().as_path().to_string_lossy());
assert!(
self.app
.remount(
Id::Config(IdConfig::TextEditor),
Box::new(components::TextEditor::new(text_editor.as_str())),
vec![]
)
.is_ok()
);
if let Err(err) = self.app.remount(
Id::Config(IdConfig::TextEditor),
Box::new(components::TextEditor::new(text_editor.as_str())),
vec![],
) {
error!("Failed to remount component: {err}");
}
// Protocol
assert!(
self.app
.remount(
Id::Config(IdConfig::DefaultProtocol),
Box::new(components::DefaultProtocol::new(
self.config().get_default_protocol()
)),
vec![]
)
.is_ok()
);
if let Err(err) = self.app.remount(
Id::Config(IdConfig::DefaultProtocol),
Box::new(components::DefaultProtocol::new(
self.config().get_default_protocol(),
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
// Hidden files
assert!(
self.app
.remount(
Id::Config(IdConfig::HiddenFiles),
Box::new(components::HiddenFiles::new(
self.config().get_show_hidden_files()
)),
vec![]
)
.is_ok()
);
if let Err(err) = self.app.remount(
Id::Config(IdConfig::HiddenFiles),
Box::new(components::HiddenFiles::new(
self.config().get_show_hidden_files(),
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
// Updates
assert!(
self.app
.remount(
Id::Config(IdConfig::CheckUpdates),
Box::new(components::CheckUpdates::new(
self.config().get_check_for_updates()
)),
vec![]
)
.is_ok()
);
if let Err(err) = self.app.remount(
Id::Config(IdConfig::CheckUpdates),
Box::new(components::CheckUpdates::new(
self.config().get_check_for_updates(),
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
// File replace
assert!(
self.app
.remount(
Id::Config(IdConfig::PromptOnFileReplace),
Box::new(components::PromptOnFileReplace::new(
self.config().get_prompt_on_file_replace()
)),
vec![]
)
.is_ok()
);
if let Err(err) = self.app.remount(
Id::Config(IdConfig::PromptOnFileReplace),
Box::new(components::PromptOnFileReplace::new(
self.config().get_prompt_on_file_replace(),
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
// Group dirs
assert!(
self.app
.remount(
Id::Config(IdConfig::GroupDirs),
Box::new(components::GroupDirs::new(self.config().get_group_dirs())),
vec![]
)
.is_ok()
);
if let Err(err) = self.app.remount(
Id::Config(IdConfig::GroupDirs),
Box::new(components::GroupDirs::new(self.config().get_group_dirs())),
vec![],
) {
error!("Failed to remount component: {err}");
}
// Local File Fmt
assert!(
self.app
.remount(
Id::Config(IdConfig::LocalFileFmt),
Box::new(components::LocalFileFmt::new(
&self.config().get_local_file_fmt().unwrap_or_default()
)),
vec![]
)
.is_ok()
);
if let Err(err) = self.app.remount(
Id::Config(IdConfig::LocalFileFmt),
Box::new(components::LocalFileFmt::new(
&self.config().get_local_file_fmt().unwrap_or_default(),
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
// Remote File Fmt
assert!(
self.app
.remount(
Id::Config(IdConfig::RemoteFileFmt),
Box::new(components::RemoteFileFmt::new(
&self.config().get_remote_file_fmt().unwrap_or_default()
)),
vec![]
)
.is_ok()
);
if let Err(err) = self.app.remount(
Id::Config(IdConfig::RemoteFileFmt),
Box::new(components::RemoteFileFmt::new(
&self.config().get_remote_file_fmt().unwrap_or_default(),
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
// Notifications enabled
assert!(
self.app
.remount(
Id::Config(IdConfig::NotificationsEnabled),
Box::new(components::NotificationsEnabled::new(
self.config().get_notifications()
)),
vec![]
)
.is_ok()
);
if let Err(err) = self.app.remount(
Id::Config(IdConfig::NotificationsEnabled),
Box::new(components::NotificationsEnabled::new(
self.config().get_notifications(),
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
// Notifications threshold
assert!(
self.app
.remount(
Id::Config(IdConfig::NotificationsThreshold),
Box::new(components::NotificationsThreshold::new(&fmt_bytes(
self.config().get_notification_threshold()
))),
vec![]
)
.is_ok()
);
if let Err(err) = self.app.remount(
Id::Config(IdConfig::NotificationsThreshold),
Box::new(components::NotificationsThreshold::new(&fmt_bytes(
self.config().get_notification_threshold(),
))),
vec![],
) {
error!("Failed to remount component: {err}");
}
// Ssh config
assert!(
self.app
.remount(
Id::Config(IdConfig::SshConfig),
Box::new(components::SshConfig::new(
self.config().get_ssh_config().unwrap_or("")
)),
vec![]
)
.is_ok()
);
if let Err(err) = self.app.remount(
Id::Config(IdConfig::SshConfig),
Box::new(components::SshConfig::new(
self.config().get_ssh_config().unwrap_or(""),
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
}
/// Collect values from input and put them into the configuration

76
src/ui/activities/setup/view/ssh_keys.rs
View File

@@ -74,16 +74,16 @@ impl SetupActivity {
/// Mount delete ssh key component
pub(crate) fn mount_del_ssh_key(&mut self) {
assert!(
self.app
.remount(
Id::Ssh(IdSsh::DelSshKeyPopup),
Box::<components::DelSshKeyPopup>::default(),
vec![]
)
.is_ok()
);
assert!(self.app.active(&Id::Ssh(IdSsh::DelSshKeyPopup)).is_ok());
if let Err(err) = self.app.remount(
Id::Ssh(IdSsh::DelSshKeyPopup),
Box::<components::DelSshKeyPopup>::default(),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.active(&Id::Ssh(IdSsh::DelSshKeyPopup)) {
error!("Failed to activate component: {err}");
}
}
/// Umount delete ssh key
@@ -93,25 +93,23 @@ impl SetupActivity {
/// Mount new ssh key prompt
pub(crate) fn mount_new_ssh_key(&mut self) {
assert!(
self.app
.remount(
Id::Ssh(IdSsh::SshHost),
Box::<components::SshHost>::default(),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Ssh(IdSsh::SshUsername),
Box::<components::SshUsername>::default(),
vec![]
)
.is_ok()
);
assert!(self.app.active(&Id::Ssh(IdSsh::SshHost)).is_ok());
if let Err(err) = self.app.remount(
Id::Ssh(IdSsh::SshHost),
Box::<components::SshHost>::default(),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Ssh(IdSsh::SshUsername),
Box::<components::SshUsername>::default(),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.active(&Id::Ssh(IdSsh::SshHost)) {
error!("Failed to activate component: {err}");
}
}
/// Umount new ssh key prompt
@@ -130,15 +128,15 @@ impl SetupActivity {
format!("{username} at {addr}")
})
.collect();
assert!(
self.app
.remount(
Id::Ssh(IdSsh::SshKeys),
Box::new(components::SshKeys::new(&keys)),
vec![]
)
.is_ok()
);
assert!(self.app.active(&Id::Ssh(IdSsh::SshKeys)).is_ok());
if let Err(err) = self.app.remount(
Id::Ssh(IdSsh::SshKeys),
Box::new(components::SshKeys::new(&keys)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.active(&Id::Ssh(IdSsh::SshKeys)) {
error!("Failed to activate component: {err}");
}
}
}

540
src/ui/activities/setup/view/theme.rs
View File

@@ -21,7 +21,9 @@ impl SetupActivity {
// Load styles
self.load_styles();
// Active first field
assert!(self.app.active(&Id::Theme(IdTheme::AuthProtocol)).is_ok());
if let Err(err) = self.app.active(&Id::Theme(IdTheme::AuthProtocol)) {
error!("Failed to activate component: {err}");
}
}
pub(super) fn view_theme(&mut self) {
@@ -242,309 +244,247 @@ impl SetupActivity {
}
fn load_titles(&mut self) {
assert!(
self.app
.remount(
Id::Theme(IdTheme::AuthTitle),
Box::<components::AuthTitle>::default(),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::MiscTitle),
Box::<components::MiscTitle>::default(),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::TransferTitle),
Box::<components::TransferTitle>::default(),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::TransferTitle2),
Box::<components::TransferTitle2>::default(),
vec![]
)
.is_ok()
);
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::AuthTitle),
Box::<components::AuthTitle>::default(),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::MiscTitle),
Box::<components::MiscTitle>::default(),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::TransferTitle),
Box::<components::TransferTitle>::default(),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::TransferTitle2),
Box::<components::TransferTitle2>::default(),
vec![],
) {
error!("Failed to remount component: {err}");
}
}
/// Load values from theme into input fields
pub(crate) fn load_styles(&mut self) {
let theme: Theme = self.theme().clone();
assert!(
self.app
.remount(
Id::Theme(IdTheme::AuthAddress),
Box::new(components::AuthAddress::new(theme.auth_address)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::AuthBookmarks),
Box::new(components::AuthBookmarks::new(theme.auth_bookmarks)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::AuthPassword),
Box::new(components::AuthPassword::new(theme.auth_password)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::AuthPort),
Box::new(components::AuthPort::new(theme.auth_port)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::AuthProtocol),
Box::new(components::AuthProtocol::new(theme.auth_protocol)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::AuthRecentHosts),
Box::new(components::AuthRecentHosts::new(theme.auth_recents)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::AuthUsername),
Box::new(components::AuthUsername::new(theme.auth_username)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::MiscError),
Box::new(components::MiscError::new(theme.misc_error_dialog)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::MiscInfo),
Box::new(components::MiscInfo::new(theme.misc_info_dialog)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::MiscInput),
Box::new(components::MiscInput::new(theme.misc_input_dialog)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::MiscKeys),
Box::new(components::MiscKeys::new(theme.misc_keys)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::MiscQuit),
Box::new(components::MiscQuit::new(theme.misc_quit_dialog)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::MiscSave),
Box::new(components::MiscSave::new(theme.misc_save_dialog)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::MiscWarn),
Box::new(components::MiscWarn::new(theme.misc_warn_dialog)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::ExplorerLocalBg),
Box::new(components::ExplorerLocalBg::new(
theme.transfer_local_explorer_background
)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::ExplorerLocalFg),
Box::new(components::ExplorerLocalFg::new(
theme.transfer_local_explorer_foreground
)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::ExplorerLocalHg),
Box::new(components::ExplorerLocalHg::new(
theme.transfer_local_explorer_highlighted
)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::ExplorerRemoteBg),
Box::new(components::ExplorerRemoteBg::new(
theme.transfer_remote_explorer_background
)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::ExplorerRemoteFg),
Box::new(components::ExplorerRemoteFg::new(
theme.transfer_remote_explorer_foreground
)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::ExplorerRemoteHg),
Box::new(components::ExplorerRemoteHg::new(
theme.transfer_remote_explorer_highlighted
)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::ProgBarFull),
Box::new(components::ProgBarFull::new(
theme.transfer_progress_bar_full
)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::ProgBarPartial),
Box::new(components::ProgBarPartial::new(
theme.transfer_progress_bar_partial
)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::LogBg),
Box::new(components::LogBg::new(theme.transfer_log_background)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::LogWindow),
Box::new(components::LogWindow::new(theme.transfer_log_window)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::StatusSorting),
Box::new(components::StatusSorting::new(
theme.transfer_status_sorting
)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::StatusHidden),
Box::new(components::StatusHidden::new(theme.transfer_status_hidden)),
vec![]
)
.is_ok()
);
assert!(
self.app
.remount(
Id::Theme(IdTheme::StatusSync),
Box::new(components::StatusSync::new(
theme.transfer_status_sync_browsing
)),
vec![]
)
.is_ok()
);
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::AuthAddress),
Box::new(components::AuthAddress::new(theme.auth_address)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::AuthBookmarks),
Box::new(components::AuthBookmarks::new(theme.auth_bookmarks)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::AuthPassword),
Box::new(components::AuthPassword::new(theme.auth_password)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::AuthPort),
Box::new(components::AuthPort::new(theme.auth_port)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::AuthProtocol),
Box::new(components::AuthProtocol::new(theme.auth_protocol)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::AuthRecentHosts),
Box::new(components::AuthRecentHosts::new(theme.auth_recents)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::AuthUsername),
Box::new(components::AuthUsername::new(theme.auth_username)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::MiscError),
Box::new(components::MiscError::new(theme.misc_error_dialog)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::MiscInfo),
Box::new(components::MiscInfo::new(theme.misc_info_dialog)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::MiscInput),
Box::new(components::MiscInput::new(theme.misc_input_dialog)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::MiscKeys),
Box::new(components::MiscKeys::new(theme.misc_keys)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::MiscQuit),
Box::new(components::MiscQuit::new(theme.misc_quit_dialog)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::MiscSave),
Box::new(components::MiscSave::new(theme.misc_save_dialog)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::MiscWarn),
Box::new(components::MiscWarn::new(theme.misc_warn_dialog)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::ExplorerLocalBg),
Box::new(components::ExplorerLocalBg::new(
theme.transfer_local_explorer_background,
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::ExplorerLocalFg),
Box::new(components::ExplorerLocalFg::new(
theme.transfer_local_explorer_foreground,
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::ExplorerLocalHg),
Box::new(components::ExplorerLocalHg::new(
theme.transfer_local_explorer_highlighted,
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::ExplorerRemoteBg),
Box::new(components::ExplorerRemoteBg::new(
theme.transfer_remote_explorer_background,
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::ExplorerRemoteFg),
Box::new(components::ExplorerRemoteFg::new(
theme.transfer_remote_explorer_foreground,
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::ExplorerRemoteHg),
Box::new(components::ExplorerRemoteHg::new(
theme.transfer_remote_explorer_highlighted,
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::ProgBarFull),
Box::new(components::ProgBarFull::new(
theme.transfer_progress_bar_full,
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::ProgBarPartial),
Box::new(components::ProgBarPartial::new(
theme.transfer_progress_bar_partial,
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::LogBg),
Box::new(components::LogBg::new(theme.transfer_log_background)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::LogWindow),
Box::new(components::LogWindow::new(theme.transfer_log_window)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::StatusSorting),
Box::new(components::StatusSorting::new(
theme.transfer_status_sorting,
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::StatusHidden),
Box::new(components::StatusHidden::new(theme.transfer_status_hidden)),
vec![],
) {
error!("Failed to remount component: {err}");
}
if let Err(err) = self.app.remount(
Id::Theme(IdTheme::StatusSync),
Box::new(components::StatusSync::new(
theme.transfer_status_sync_browsing,
)),
vec![],
) {
error!("Failed to remount component: {err}");
}
}
}