me/iced
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Implement content_fit for viewer

Browse source
This commit is contained in:
gigas002 2024-03-15 21:54:49 +09:00
parent 0524e9b457
commit 15f1566578
1 changed files with 49 additions and 77 deletions
Download patch file Download diff file Expand all files Collapse all files

126
widget/src/image/viewer.rs
View file

@ -1,4 +1,5 @@
//! Zoom and pan on an image.
use iced_renderer::core::ContentFit;
use crate::core::event::{self, Event};
use crate::core::image;
use crate::core::layout;
@ -23,6 +24,7 @@ pub struct Viewer<Handle> {
scale_step: f32,
handle: Handle,
filter_method: image::FilterMethod,
content_fit: ContentFit,
}
impl<Handle> Viewer<Handle> {
@ -37,6 +39,7 @@ impl<Handle> Viewer<Handle> {
max_scale: 10.0,
scale_step: 0.10,
filter_method: image::FilterMethod::default(),
content_fit: ContentFit::Contain,
}
}
@ -46,6 +49,12 @@ impl<Handle> Viewer<Handle> {
self
}
/// Sets the [`iced_renderer::core::ContentFit`] of the [`Viewer`].
pub fn content_fit(mut self, content_fit: ContentFit) -> Self {
self.content_fit = content_fit;
self
}
/// Sets the padding of the [`Viewer`].
pub fn padding(mut self, padding: impl Into<Pixels>) -> Self {
self.padding = padding.into().0;
@ -117,36 +126,25 @@ where
renderer: &Renderer,
limits: &layout::Limits,
) -> layout::Node {
let Size { width, height } = renderer.dimensions(&self.handle);
let image_size = {
let Size { width, height } = renderer.dimensions(&self.handle);
Size::new(width as f32, height as f32)
};
let raw_size = limits.resolve(self.width, self.height, image_size);
let full_size = self.content_fit.fit(image_size, raw_size);
let mut size = limits.resolve(
self.width,
self.height,
Size::new(width as f32, height as f32),
);
let expansion_size = if height > width {
self.width
} else {
self.height
let final_size = Size {
width: match self.width {
Length::Shrink => f32::min(raw_size.width, full_size.width),
_ => raw_size.width,
},
height: match self.height {
Length::Shrink => f32::min(raw_size.height, full_size.height),
_ => raw_size.height,
},
};
// Only calculate viewport sizes if the images are constrained to a limited space.
// If they are Fill|Portion let them expand within their allotted space.
match expansion_size {
Length::Shrink | Length::Fixed(_) => {
let aspect_ratio = width as f32 / height as f32;
let viewport_aspect_ratio = size.width / size.height;
if viewport_aspect_ratio > aspect_ratio {
size.width = width as f32 * size.height / height as f32;
} else {
size.height = height as f32 * size.width / width as f32;
}
}
Length::Fill | Length::FillPortion(_) => {}
}
layout::Node::new(size)
layout::Node::new(final_size)
}
fn on_event(
@ -184,12 +182,7 @@ where
})
.clamp(self.min_scale, self.max_scale);
let image_size = image_size(
renderer,
&self.handle,
state,
bounds.size(),
);
let image_size = image_size(renderer, &self.handle, state, bounds.size(), self.content_fit);
let factor = state.scale / previous_scale - 1.0;
@ -231,7 +224,7 @@ where
}
Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)) => {
let state = tree.state.downcast_mut::<State>();
if state.cursor_grabbed_at.is_some() {
state.cursor_grabbed_at = None;
@ -242,15 +235,9 @@ where
}
Event::Mouse(mouse::Event::CursorMoved { position }) => {
let state = tree.state.downcast_mut::<State>();
if let Some(origin) = state.cursor_grabbed_at {
let image_size = image_size(
renderer,
&self.handle,
state,
bounds.size(),
);
let image_size = image_size(renderer, &self.handle, state, bounds.size(), self.content_fit);
let hidden_width = (image_size.width - bounds.width / 2.0)
.max(0.0)
.round();
@ -321,32 +308,30 @@ where
let state = tree.state.downcast_ref::<State>();
let bounds = layout.bounds();
let image_size =
image_size(renderer, &self.handle, state, bounds.size());
let image_size = image_size(renderer, &self.handle, state, bounds.size(), self.content_fit);
let translation = {
let translation = {
let image_top_left = Vector::new(
bounds.width / 2.0 - image_size.width / 2.0,
bounds.height / 2.0 - image_size.height / 2.0,
(bounds.width - image_size.width).max(0.0) / 2.0,
(bounds.height - image_size.height).max(0.0) / 2.0,
);
image_top_left - state.offset(bounds, image_size)
};
renderer.with_layer(bounds, |renderer| {
let render = |renderer: &mut Renderer| {
renderer.with_translation(translation, |renderer| {
image::Renderer::draw(
renderer,
self.handle.clone(),
self.filter_method,
Rectangle {
x: bounds.x,
y: bounds.y,
..Rectangle::with_size(image_size)
},
);
let drawing_bounds = Rectangle {
width: image_size.width,
height: image_size.height,
..bounds
};
renderer.draw(self.handle.clone(), self.filter_method, drawing_bounds);
});
});
};
renderer.with_layer(bounds, render);
}
}
@ -417,27 +402,14 @@ pub fn image_size<Renderer>(
handle: &<Renderer as image::Renderer>::Handle,
state: &State,
bounds: Size,
content_fit: ContentFit,
) -> Size
where
Renderer: image::Renderer,
{
let Size { width, height } = renderer.dimensions(handle);
let size = renderer.dimensions(handle);
let size = Size::new(size.width as f32, size.height as f32);
let size = content_fit.fit(size, bounds);
let (width, height) = {
let dimensions = (width as f32, height as f32);
let width_ratio = bounds.width / dimensions.0;
let height_ratio = bounds.height / dimensions.1;
let ratio = width_ratio.min(height_ratio);
let scale = state.scale;
if ratio < 1.0 {
(dimensions.0 * ratio * scale, dimensions.1 * ratio * scale)
} else {
(dimensions.0 * scale, dimensions.1 * scale)
}
};
Size::new(width, height)
Size::new(size.width * state.scale, size.height * state.scale)
}