138 lines
3.3 KiB
Rust
138 lines
3.3 KiB
Rust
use super::{constrain_size_preserving_aspect_ratio, Border};
|
|
use crate::{
|
|
geometry::{
|
|
rect::RectF,
|
|
vector::{vec2f, Vector2F},
|
|
},
|
|
json::{json, ToJson},
|
|
scene, Element, ImageData, SizeConstraint, ViewContext,
|
|
};
|
|
use schemars::JsonSchema;
|
|
use serde::Deserialize;
|
|
use std::{ops::Range, sync::Arc};
|
|
|
|
enum ImageSource {
|
|
Path(&'static str),
|
|
Data(Arc<ImageData>),
|
|
}
|
|
|
|
pub struct Image {
|
|
source: ImageSource,
|
|
style: ImageStyle,
|
|
}
|
|
|
|
#[derive(Copy, Clone, Default, Deserialize, JsonSchema)]
|
|
pub struct ImageStyle {
|
|
#[serde(default)]
|
|
pub border: Border,
|
|
#[serde(default)]
|
|
pub corner_radius: f32,
|
|
#[serde(default)]
|
|
pub height: Option<f32>,
|
|
#[serde(default)]
|
|
pub width: Option<f32>,
|
|
#[serde(default)]
|
|
pub grayscale: bool,
|
|
}
|
|
|
|
impl Image {
|
|
pub fn new(asset_path: &'static str) -> Self {
|
|
Self {
|
|
source: ImageSource::Path(asset_path),
|
|
style: Default::default(),
|
|
}
|
|
}
|
|
|
|
pub fn from_data(data: Arc<ImageData>) -> Self {
|
|
Self {
|
|
source: ImageSource::Data(data),
|
|
style: Default::default(),
|
|
}
|
|
}
|
|
|
|
pub fn with_style(mut self, style: ImageStyle) -> Self {
|
|
self.style = style;
|
|
self
|
|
}
|
|
}
|
|
|
|
impl<V: 'static> Element<V> for Image {
|
|
type LayoutState = Option<Arc<ImageData>>;
|
|
type PaintState = ();
|
|
|
|
fn layout(
|
|
&mut self,
|
|
constraint: SizeConstraint,
|
|
_: &mut V,
|
|
cx: &mut ViewContext<V>,
|
|
) -> (Vector2F, Self::LayoutState) {
|
|
let data = match &self.source {
|
|
ImageSource::Path(path) => match cx.asset_cache.png(path) {
|
|
Ok(data) => data,
|
|
Err(error) => {
|
|
log::error!("could not load image: {}", error);
|
|
return (Vector2F::zero(), None);
|
|
}
|
|
},
|
|
ImageSource::Data(data) => data.clone(),
|
|
};
|
|
|
|
let desired_size = vec2f(
|
|
self.style.width.unwrap_or_else(|| constraint.max.x()),
|
|
self.style.height.unwrap_or_else(|| constraint.max.y()),
|
|
);
|
|
let size = constrain_size_preserving_aspect_ratio(
|
|
constraint.constrain(desired_size),
|
|
data.size().to_f32(),
|
|
);
|
|
|
|
(size, Some(data))
|
|
}
|
|
|
|
fn paint(
|
|
&mut self,
|
|
bounds: RectF,
|
|
_: RectF,
|
|
layout: &mut Self::LayoutState,
|
|
_: &mut V,
|
|
cx: &mut ViewContext<V>,
|
|
) -> Self::PaintState {
|
|
if let Some(data) = layout {
|
|
cx.scene().push_image(scene::Image {
|
|
bounds,
|
|
border: self.style.border.into(),
|
|
corner_radii: self.style.corner_radius.into(),
|
|
grayscale: self.style.grayscale,
|
|
data: data.clone(),
|
|
});
|
|
}
|
|
}
|
|
|
|
fn rect_for_text_range(
|
|
&self,
|
|
_: Range<usize>,
|
|
_: RectF,
|
|
_: RectF,
|
|
_: &Self::LayoutState,
|
|
_: &Self::PaintState,
|
|
_: &V,
|
|
_: &ViewContext<V>,
|
|
) -> Option<RectF> {
|
|
None
|
|
}
|
|
|
|
fn debug(
|
|
&self,
|
|
bounds: RectF,
|
|
_: &Self::LayoutState,
|
|
_: &Self::PaintState,
|
|
_: &V,
|
|
_: &ViewContext<V>,
|
|
) -> serde_json::Value {
|
|
json!({
|
|
"type": "Image",
|
|
"bounds": bounds.to_json(),
|
|
})
|
|
}
|
|
}
|