104 lines
2.6 KiB
Rust
104 lines
2.6 KiB
Rust
use std::hash::Hash;
|
|
|
|
use crate::{layout, Element, Event, Hasher, Layout, Length, Point, Widget};
|
|
|
|
/// A container that distributes its contents horizontally.
|
|
pub type Row<'a, Message, Renderer> =
|
|
iced_core::Row<Element<'a, Message, Renderer>>;
|
|
|
|
impl<'a, Message, Renderer> Widget<Message, Renderer>
|
|
for Row<'a, Message, Renderer>
|
|
where
|
|
Renderer: self::Renderer,
|
|
{
|
|
fn width(&self) -> Length {
|
|
self.width
|
|
}
|
|
|
|
fn layout(
|
|
&self,
|
|
renderer: &Renderer,
|
|
limits: &layout::Limits,
|
|
) -> layout::Node {
|
|
let limits = limits
|
|
.max_width(self.max_width)
|
|
.max_height(self.max_height)
|
|
.width(self.width)
|
|
.height(self.height);
|
|
|
|
layout::flex::resolve(
|
|
layout::flex::Axis::Horizontal,
|
|
renderer,
|
|
&limits,
|
|
self.padding as f32,
|
|
self.spacing as f32,
|
|
self.align_items,
|
|
&self.children,
|
|
)
|
|
}
|
|
|
|
fn on_event(
|
|
&mut self,
|
|
event: Event,
|
|
layout: Layout<'_>,
|
|
cursor_position: Point,
|
|
messages: &mut Vec<Message>,
|
|
renderer: &Renderer,
|
|
) {
|
|
self.children.iter_mut().zip(layout.children()).for_each(
|
|
|(child, layout)| {
|
|
child.widget.on_event(
|
|
event,
|
|
layout,
|
|
cursor_position,
|
|
messages,
|
|
renderer,
|
|
)
|
|
},
|
|
);
|
|
}
|
|
|
|
fn draw(
|
|
&self,
|
|
renderer: &mut Renderer,
|
|
layout: Layout<'_>,
|
|
cursor_position: Point,
|
|
) -> Renderer::Output {
|
|
renderer.draw(&self, layout, cursor_position)
|
|
}
|
|
|
|
fn hash_layout(&self, state: &mut Hasher) {
|
|
1.hash(state);
|
|
self.width.hash(state);
|
|
self.height.hash(state);
|
|
self.max_width.hash(state);
|
|
self.max_height.hash(state);
|
|
self.align_items.hash(state);
|
|
self.spacing.hash(state);
|
|
self.spacing.hash(state);
|
|
|
|
for child in &self.children {
|
|
child.widget.hash_layout(state);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub trait Renderer: crate::Renderer + Sized {
|
|
fn draw<Message>(
|
|
&mut self,
|
|
row: &Row<'_, Message, Self>,
|
|
layout: Layout<'_>,
|
|
cursor_position: Point,
|
|
) -> Self::Output;
|
|
}
|
|
|
|
impl<'a, Message, Renderer> From<Row<'a, Message, Renderer>>
|
|
for Element<'a, Message, Renderer>
|
|
where
|
|
Renderer: 'a + self::Renderer,
|
|
Message: 'static,
|
|
{
|
|
fn from(row: Row<'a, Message, Renderer>) -> Element<'a, Message, Renderer> {
|
|
Element::new(row)
|
|
}
|
|
}
|