lazzexus/Loupe
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

code: Use chained if-let's

Browse source
This commit is contained in:
Sophie Herold 2026-01-29 19:04:26 +01:00
parent f806bbd484
commit 8972c5efb9
12 changed files with 219 additions and 235 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/decoder.rs
View file

@ -201,10 +201,10 @@ impl Decoder {
/// Request missing tiles /// Request missing tiles
pub fn request(&self, tile_request: TileRequest) { pub fn request(&self, tile_request: TileRequest) {
if let FormatDecoder::Svg(svg) = &self.decoder { if let FormatDecoder::Svg(svg) = &self.decoder
if let Err(err) = svg.request(tile_request) { && let Err(err) = svg.request(tile_request)
tracing::error!("Failed to request new SVG tiles: {err}"); {
} tracing::error!("Failed to request new SVG tiles: {err}");
} }
} }

9
src/metadata.rs
View file

@ -369,12 +369,11 @@ impl Metadata {
let location_exact = libgweather::Location::new_detached("", None, lat, lon); let location_exact = libgweather::Location::new_detached("", None, lat, lon);
// do not use city if more than 15 km away // do not use city if more than 15 km away
if nearest_city.distance(&location_exact) < 15. { if nearest_city.distance(&location_exact) < 15.
if let (Some(city), Some(country)) = && let (Some(city), Some(country)) =
(nearest_city.city_name(), nearest_city.country_name()) (nearest_city.city_name(), nearest_city.country_name())
{ {
return Some(format!("{city}, {country}")); return Some(format!("{city}, {country}"));
}
} }
} }

9
src/util/gettext.rs
View file

@ -63,10 +63,11 @@ pub fn apply_unicode_escapes(s: impl AsRef<str>) -> Option<String> {
while let Some(c) = char_iter.next() { while let Some(c) = char_iter.next() {
match state { match state {
State::None if c == '\\' => { State::None if c == '\\' => {
if let (Some(c1), Some(c2)) = (char_iter.next(), char_iter.next()) { if let (Some(c1), Some(c2)) = (char_iter.next(), char_iter.next())
if c1 == 'u' && c2 == '{' { && c1 == 'u'
state = State::UnicodeHex; && c2 == '{'
} {
state = State::UnicodeHex;
} }
} }
State::None => new.push(c), State::None => new.push(c),

118
src/widgets/edit_window.rs
View file

@ -252,87 +252,81 @@ mod imp {
let obj = self.obj(); let obj = self.obj();
self.save.popdown(); self.save.popdown();
if let Some(original_file) = obj.original_image().file() { if let Some(original_file) = obj.original_image().file()
if let Some(current_path) = original_file.path() { && let Some(current_path) = original_file.path()
if let Some(mut file_stem) = current_path.file_stem().map(|x| x.to_os_string()) && let Some(mut file_stem) = current_path.file_stem().map(|x| x.to_os_string())
{ {
let mut tmp_path = current_path.clone(); let mut tmp_path = current_path.clone();
file_stem.push(".tmp"); file_stem.push(".tmp");
if let Some(ext) = current_path.extension() { if let Some(ext) = current_path.extension() {
file_stem.push("."); file_stem.push(".");
file_stem.push(ext); file_stem.push(ext);
} }
tmp_path.set_file_name(file_stem); tmp_path.set_file_name(file_stem);
let tmp_file = gio::File::for_path(&tmp_path); let tmp_file = gio::File::for_path(&tmp_path);
let cancellable = gio::Cancellable::new(); let cancellable = gio::Cancellable::new();
if let Some(old_cancellable) = if let Some(old_cancellable) =
self.save_cancellable.replace(Some(cancellable.clone())) self.save_cancellable.replace(Some(cancellable.clone()))
{ {
old_cancellable.cancel(); old_cancellable.cancel();
} }
let written = self let written = self
.save(original_file.clone(), tmp_file.clone(), cancellable.clone()) .save(original_file.clone(), tmp_file.clone(), cancellable.clone())
.await; .await;
if written { if written {
tracing::debug!("Moving image to trash '{}'", original_file.uri()); tracing::debug!("Moving image to trash '{}'", original_file.uri());
let trash_result = gio::CancellableFuture::new( let trash_result = gio::CancellableFuture::new(
original_file.trash_future(glib::Priority::DEFAULT), original_file.trash_future(glib::Priority::DEFAULT),
cancellable.clone(), cancellable.clone(),
) )
.await; .await;
if trash_result.is_err() { if trash_result.is_err() {
// Canceled // Canceled
tracing::debug!("Trashing image canceled"); tracing::debug!("Trashing image canceled");
return; return;
} else if let Ok(Err(err)) = trash_result { } else if let Ok(Err(err)) = trash_result {
obj.window_show_error( obj.window_show_error(
&gettext("Failed to save image."), &gettext("Failed to save image."),
&format!("Failed to move image {current_path:?} to trash and therefore couldn't save image: {err}"), &format!("Failed to move image {current_path:?} to trash and therefore couldn't save image: {err}"),
ErrorType::General, ErrorType::General,
); );
return; return;
} }
tracing::debug!( tracing::debug!("Moving '{}' to '{}'", tmp_file.uri(), original_file.uri());
"Moving '{}' to '{}'", let move_result = gio::CancellableFuture::new(
tmp_file.uri(), tmp_file
original_file.uri() .move_future(
); &original_file,
let move_result = gio::CancellableFuture::new( gio::FileCopyFlags::NONE,
tmp_file glib::Priority::DEFAULT,
.move_future(
&original_file,
gio::FileCopyFlags::NONE,
glib::Priority::DEFAULT,
)
.0,
cancellable.clone(),
) )
.await; .0,
cancellable.clone(),
)
.await;
if move_result.is_err() { if move_result.is_err() {
// Canceled // Canceled
tracing::debug!("Moving image canceled"); tracing::debug!("Moving image canceled");
return; return;
} else if let Ok(Err(err)) = move_result { } else if let Ok(Err(err)) = move_result {
obj.window_show_error( obj.window_show_error(
&gettext("Failed to save image."), &gettext("Failed to save image."),
&format!( &format!(
"Failed to move image image to {current_path:?}: {err} move {:?} to {:?}", tmp_file.path().unwrap(), original_file.path().unwrap() "Failed to move image image to {current_path:?}: {err} move {:?} to {:?}", tmp_file.path().unwrap(), original_file.path().unwrap()
), ),
ErrorType::General, ErrorType::General,
); );
return; return;
}
obj.window_inspect(|w| w.show_specific_image(original_file));
}
} }
obj.window_inspect(|w| w.show_specific_image(original_file));
} }
} }
} }

20
src/widgets/image/input_handling.rs
View file

@ -303,17 +303,17 @@ impl imp::LpImage {
let zoom = imp.zoom_target.get() * scale; let zoom = imp.zoom_target.get() * scale;
// Move image with fingers on touchscreens // Move image with fingers on touchscreens
if gesture.device().map(|x| x.source()) == Some(gdk::InputSource::Touchscreen) { if gesture.device().map(|x| x.source()) == Some(gdk::InputSource::Touchscreen)
if let p1 @ Some((x1, y1)) = gesture.bounding_box_center() { && let p1 @ Some((x1, y1)) = gesture.bounding_box_center()
if let Some((x0, y0)) = imp.zoom_gesture_center.get() { {
imp.set_hadj_value(imp.hadj_value() + x0 - x1); if let Some((x0, y0)) = imp.zoom_gesture_center.get() {
imp.set_vadj_value(imp.vadj_value() + y0 - y1); imp.set_hadj_value(imp.hadj_value() + x0 - x1);
} else { imp.set_vadj_value(imp.vadj_value() + y0 - y1);
tracing::warn!("Zoom bounding box center: No previous value"); } else {
} tracing::warn!("Zoom bounding box center: No previous value");
imp.zoom_gesture_center.set(p1);
} }
imp.zoom_gesture_center.set(p1);
} }
let zoom_out_threshold = 1. / ZOOM_GESTURE_LOCK_THRESHOLD; let zoom_out_threshold = 1. / ZOOM_GESTURE_LOCK_THRESHOLD;

43
src/widgets/image/loading.rs
View file

@ -186,19 +186,19 @@ impl imp::LpImage {
} }
pub(super) fn request_tiles(&self) { pub(super) fn request_tiles(&self) {
if let Some(decoder) = self.decoder.borrow().as_ref() { if let Some(decoder) = self.decoder.borrow().as_ref()
if self.zoom_animation().state() != adw::AnimationState::Playing { && self.zoom_animation().state() != adw::AnimationState::Playing
// Force minimum tile size of 1000x1000 since with smaller {
// tiles the tiled rendering advantage disappears // Force minimum tile size of 1000x1000 since with smaller
let x_inset = f32::min(-3., (self.viewport().width() - 1000.) / 2.); // tiles the tiled rendering advantage disappears
let y_inset = f32::min(-3., (self.viewport().height() - 1000.) / 2.); let x_inset = f32::min(-3., (self.viewport().width() - 1000.) / 2.);
let y_inset = f32::min(-3., (self.viewport().height() - 1000.) / 2.);
decoder.request(crate::decoder::TileRequest { decoder.request(crate::decoder::TileRequest {
viewport: self.viewport().inset_r(x_inset, y_inset), viewport: self.viewport().inset_r(x_inset, y_inset),
area: self.preload_area(), area: self.preload_area(),
zoom: self.zoom_target.get(), zoom: self.zoom_target.get(),
}); });
}
} }
} }
@ -287,19 +287,16 @@ impl imp::LpImage {
async fn check_editable(&self) { async fn check_editable(&self) {
let obj = self.obj(); let obj = self.obj();
if let Some(mime_type) = obj.metadata().mime_type() { if let Some(mime_type) = obj.metadata().mime_type()
if let Ok(supported_formats) = glycin::config::Config::cached() && let Ok(supported_formats) = glycin::config::Config::cached()
.await .await
.editor(&mime_type.as_str().into()) .editor(&mime_type.as_str().into())
{ && LpEditWindow::REQUIRED_OPERATIONS
if LpEditWindow::REQUIRED_OPERATIONS .iter()
.iter() .all(|x| supported_formats.operations.contains(x))
.all(|x| supported_formats.operations.contains(x)) {
{ self.editable.set(true);
self.editable.set(true); obj.notify_editable();
obj.notify_editable();
}
}
}; };
} }
} }

122
src/widgets/image/rendering.rs
View file

@ -158,62 +158,61 @@ impl WidgetImpl for imp::LpImage {
let image_width = image_width_i32 as f64; let image_width = image_width_i32 as f64;
let image_height = image_height_i32 as f64; let image_height = image_height_i32 as f64;
if image_width_i32 > 0 && image_height_i32 > 0 { if image_width_i32 > 0
if let Some((monitor_width, monitor_height)) = self.monitor_size() { && image_height_i32 > 0
let hidpi_scale = self.scaling(); && let Some((monitor_width, monitor_height)) = self.monitor_size()
tracing::trace!("Physical monitor dimensions: {monitor_width} x {monitor_height}"); {
let hidpi_scale = self.scaling();
tracing::trace!("Physical monitor dimensions: {monitor_width} x {monitor_height}");
// areas // areas
let monitor_area = monitor_width * monitor_height; let monitor_area = monitor_width * monitor_height;
let logical_monitor_area = monitor_area * hidpi_scale.powi(2); let logical_monitor_area = monitor_area * hidpi_scale.powi(2);
let image_area = image_width * image_height; let image_area = image_width * image_height;
let occupy_area_factor = if logical_monitor_area <= SMALL_SCREEN_AREA { let occupy_area_factor = if logical_monitor_area <= SMALL_SCREEN_AREA {
tracing::trace!( tracing::trace!("Small monitor detected: Using {SMALL_OCCUPY_SCREEN} screen area");
"Small monitor detected: Using {SMALL_OCCUPY_SCREEN} screen area" SMALL_OCCUPY_SCREEN
); } else {
SMALL_OCCUPY_SCREEN tracing::trace!(
} else { "Sufficiently large monitor detected: Using {DEFAULT_OCCUPY_SCREEN} screen area"
tracing::trace!( );
"Sufficiently large monitor detected: Using {DEFAULT_OCCUPY_SCREEN} screen area" DEFAULT_OCCUPY_SCREEN
); };
DEFAULT_OCCUPY_SCREEN
};
// factor for width and height that will achieve the desired area // factor for width and height that will achieve the desired area
// occupation derived from: // occupation derived from:
// monitor_area * occupy_area_factor == // monitor_area * occupy_area_factor ==
// (image_width * size_scale) * (image_height * size_scale) // (image_width * size_scale) * (image_height * size_scale)
let size_scale = f64::sqrt(monitor_area / image_area * occupy_area_factor); let size_scale = f64::sqrt(monitor_area / image_area * occupy_area_factor);
// ensure that we never increase image size // ensure that we never increase image size
let target_scale = f64::min(1.0, size_scale); let target_scale = f64::min(1.0, size_scale);
let mut nat_width = image_width * target_scale; let mut nat_width = image_width * target_scale;
let mut nat_height = image_height * target_scale; let mut nat_height = image_height * target_scale;
// Scale down if targeted occupation does not fit horizontally // Scale down if targeted occupation does not fit horizontally
// Add some margin to not touch corners // Add some margin to not touch corners
let max_width = monitor_width - 20.; let max_width = monitor_width - 20.;
if nat_width > max_width { if nat_width > max_width {
nat_width = max_width; nat_width = max_width;
nat_height = image_height * nat_width / image_width; nat_height = image_height * nat_width / image_width;
}
// Same for vertical size
// Additionally substract some space for HeaderBar and Shell bar
let max_height = monitor_height - (50. + 35. + 20.) * hidpi_scale;
if nat_height > max_height {
nat_height = max_height;
nat_width = image_width * nat_height / image_height;
}
let size = match orientation {
gtk::Orientation::Horizontal => (nat_width / hidpi_scale).round(),
gtk::Orientation::Vertical => (nat_height / hidpi_scale).round(),
_ => unreachable!(),
};
return (0, size as i32, -1, -1);
} }
// Same for vertical size
// Additionally substract some space for HeaderBar and Shell bar
let max_height = monitor_height - (50. + 35. + 20.) * hidpi_scale;
if nat_height > max_height {
nat_height = max_height;
nat_width = image_width * nat_height / image_height;
}
let size = match orientation {
gtk::Orientation::Horizontal => (nat_width / hidpi_scale).round(),
gtk::Orientation::Vertical => (nat_height / hidpi_scale).round(),
_ => unreachable!(),
};
return (0, size as i32, -1, -1);
} }
// fallback if monitor size or image size is not known: // fallback if monitor size or image size is not known:
@ -338,18 +337,17 @@ impl imp::LpImage {
pub fn monitor_size(&self) -> Option<(f64, f64)> { pub fn monitor_size(&self) -> Option<(f64, f64)> {
let obj = self.obj(); let obj = self.obj();
if let Some(display) = gdk::Display::default() { if let Some(display) = gdk::Display::default()
if let Some(surface) = obj.native().and_then(|x| x.surface()) { && let Some(surface) = obj.native().and_then(|x| x.surface())
if let Some(monitor) = display.monitor_at_surface(&surface) { && let Some(monitor) = display.monitor_at_surface(&surface)
let hidpi_scale = self.scaling(); {
let monitor_geometry = monitor.geometry(); let hidpi_scale = self.scaling();
let monitor_geometry = monitor.geometry();
return Some(( return Some((
monitor_geometry.width() as f64 * hidpi_scale, monitor_geometry.width() as f64 * hidpi_scale,
monitor_geometry.height() as f64 * hidpi_scale, monitor_geometry.height() as f64 * hidpi_scale,
)); ));
}
}
} }
None None

16
src/widgets/image/rotation.rs
View file

@ -104,14 +104,14 @@ impl LpImage {
zoom_animation.play(); zoom_animation.play();
} }
if let Ok(r) = gufo_common::orientation::Rotation::try_from(angle) { if let Ok(r) = gufo_common::orientation::Rotation::try_from(angle)
if r != gufo_common::orientation::Rotation::_0 { && r != gufo_common::orientation::Rotation::_0
tracing::debug!("Editing image to rotate by {r:?}"); {
let operation = glycin::Operation::Rotate(r); tracing::debug!("Editing image to rotate by {r:?}");
let editing_queue = &self.imp().editing_queue; let operation = glycin::Operation::Rotate(r);
editing_queue.push(operation); let editing_queue = &self.imp().editing_queue;
editing_queue.write_to_image(self); editing_queue.push(operation);
} editing_queue.write_to_image(self);
} }
} }
} }

30
src/widgets/image_view.rs
View file

@ -303,10 +303,10 @@ mod imp {
#[weak] #[weak]
obj, obj,
move |_| { move |_| {
if let Some(page) = obj.current_page() { if let Some(page) = obj.current_page()
if let Some(value) = obj.zoom_value_f64() { && let Some(value) = obj.zoom_value_f64()
page.image().zoom_to_no_best_fit(value); {
} page.image().zoom_to_no_best_fit(value);
} }
} }
)); ));
@ -717,13 +717,13 @@ impl LpImageView {
/// Handle files are added or removed from directory /// Handle files are added or removed from directory
fn model_content_changed_cb(&self, file_event: &FileEvent) { fn model_content_changed_cb(&self, file_event: &FileEvent) {
// Animate to image that was restored from trash // Animate to image that was restored from trash
if let Some(trash_restore) = self.trash_restore() { if let Some(trash_restore) = self.trash_restore()
if self.model().contains_file(&trash_restore) { && self.model().contains_file(&trash_restore)
self.set_trash_restore(gio::File::NONE); {
self.update_sliding_view(&trash_restore); self.set_trash_restore(gio::File::NONE);
self.scroll_sliding_view(&trash_restore, true); self.update_sliding_view(&trash_restore);
return; self.scroll_sliding_view(&trash_restore, true);
} return;
} }
let Some(current_file) = self.current_file() else { let Some(current_file) = self.current_file() else {
@ -742,10 +742,10 @@ impl LpImageView {
page.image().init(&target_file); page.image().init(&target_file);
} }
// File that delayed move is set for is now available // File that delayed move is set for is now available
if let Some(delayed_current_file) = self.delayed_current_file() { if let Some(delayed_current_file) = self.delayed_current_file()
if target_file.equal(&delayed_current_file) { && target_file.equal(&delayed_current_file)
self.navigate_to_file(&delayed_current_file); {
} self.navigate_to_file(&delayed_current_file);
} }
} }
FileEvent::New(new) => { FileEvent::New(new) => {

19
src/widgets/image_window.rs
View file

@ -575,10 +575,10 @@ impl LpImageWindow {
if let Some(ref file) = imp.image_view.current_file() { if let Some(ref file) = imp.image_view.current_file() {
let launcher = gtk::FileLauncher::new(Some(file)); let launcher = gtk::FileLauncher::new(Some(file));
launcher.set_always_ask(true); launcher.set_always_ask(true);
if let Err(e) = launcher.launch_future(self.try_window().as_ref()).await { if let Err(e) = launcher.launch_future(self.try_window().as_ref()).await
if !e.matches(gtk::DialogError::Dismissed) { && !e.matches(gtk::DialogError::Dismissed)
tracing::error!("Could not open image in external program: {}", e); {
} tracing::error!("Could not open image in external program: {}", e);
} }
} else { } else {
tracing::error!("Could not load a path for the current image.") tracing::error!("Could not load a path for the current image.")
@ -611,12 +611,11 @@ impl LpImageWindow {
return false; return false;
}; };
if let Some(focus_widget) = GtkWindowExt::focus(&window) { if let Some(focus_widget) = GtkWindowExt::focus(&window)
if focus_widget.is_ancestor(&*self.imp().properties_view) { && focus_widget.is_ancestor(&*self.imp().properties_view)
if let Ok(label) = focus_widget.downcast::<gtk::Label>() { && let Ok(label) = focus_widget.downcast::<gtk::Label>()
return label.selection_bounds().is_some(); {
} return label.selection_bounds().is_some();
}
} }
false false

14
src/widgets/print.rs
View file

@ -388,17 +388,15 @@ mod imp {
.set_value(size_unit.round(obj.original_size().0 * obj.width_unit_factor())); .set_value(size_unit.round(obj.original_size().0 * obj.width_unit_factor()));
// Default to inch for USA and Liberia // Default to inch for USA and Liberia
if let Some(unit_locale) = getlocale(gettextrs::LocaleCategory::LcMeasurement) { if let Some(unit_locale) = getlocale(gettextrs::LocaleCategory::LcMeasurement)
if let Some(locale) = unit_locale && let Some(locale) = unit_locale
.split(|x| *x == b'_') .split(|x| *x == b'_')
.nth(1) .nth(1)
.and_then(|x| x.get(0..2)) .and_then(|x| x.get(0..2))
{ && (locale == b"US" || locale == b"LR")
if locale == b"US" || locale == b"LR" { {
imp.margin_unit.set_selected(Unit::Inch as u32); imp.margin_unit.set_selected(Unit::Inch as u32);
imp.size_unit.set_selected(Unit::Inch as u32); imp.size_unit.set_selected(Unit::Inch as u32);
}
}
} }
let orientation = match obj.page_setup().orientation() { let orientation = match obj.page_setup().orientation() {

46
src/widgets/sliding_view.rs
View file

@ -246,20 +246,19 @@ mod imp {
if matches!( if matches!(
*self.position_tracking.borrow(), *self.position_tracking.borrow(),
PositionTracking::Position(_) PositionTracking::Position(_)
) { ) && let Some(mut child) = obj.first_child()
if let Some(mut child) = obj.first_child() { {
let mut children = vec![child.clone()]; let mut children = vec![child.clone()];
while let Some(new_child) = child.next_sibling() { while let Some(new_child) = child.next_sibling() {
child = new_child; child = new_child;
children.push(child.clone()); children.push(child.clone());
} }
for child in children { for child in children {
if let Ok(page) = child.downcast::<LpImagePage>() { if let Ok(page) = child.downcast::<LpImagePage>()
if obj.index_of(&page).is_none() { && obj.index_of(&page).is_none()
page.unparent(); {
} page.unparent();
}
} }
} }
} }
@ -612,19 +611,18 @@ impl LpSlidingView {
/// Move to image with cards animation /// Move to image with cards animation
fn step_to(&self, page: &LpImagePage) { fn step_to(&self, page: &LpImagePage) {
let animation = self.step_animation(); let animation = self.step_animation();
if let Some(prev_page) = self.current_page() { if let Some(prev_page) = self.current_page()
if let (Some(prev_index), Some(new_index)) = && let (Some(prev_index), Some(new_index)) =
(self.index_of(&prev_page), self.index_of(page)) (self.index_of(&prev_page), self.index_of(page))
{ {
let backward = new_index < prev_index; let backward = new_index < prev_index;
*self.imp().position_tracking.borrow_mut() = *self.imp().position_tracking.borrow_mut() =
PositionTracking::StackedCards(StackedCards::new(prev_page, backward)); PositionTracking::StackedCards(StackedCards::new(prev_page, backward));
// Set current page here as well, to make sure it's set when animation completes // Set current page here as well, to make sure it's set when animation completes
// for disabled animations // for disabled animations
self.set_current_page(Some(page)); self.set_current_page(Some(page));
animation.play(); animation.play();
}
} }
self.set_current_page(Some(page)); self.set_current_page(Some(page));
} }