1use crate::core::alignment::{self, Alignment};
3use crate::core::layout::{self, Layout};
4use crate::core::mouse;
5use crate::core::overlay;
6use crate::core::renderer;
7use crate::core::widget::{Operation, Tree};
8use crate::core::{
9 Clipboard, Element, Event, Length, Padding, Pixels, Rectangle, Shell, Size,
10 Vector, Widget,
11};
12
13#[allow(missing_debug_implementations)]
36pub struct Row<'a, Message, Theme = crate::Theme, Renderer = crate::Renderer> {
37 spacing: f32,
38 padding: Padding,
39 width: Length,
40 height: Length,
41 align: Alignment,
42 clip: bool,
43 children: Vec<Element<'a, Message, Theme, Renderer>>,
44}
45
46impl<'a, Message, Theme, Renderer> Row<'a, Message, Theme, Renderer>
47where
48 Renderer: crate::core::Renderer,
49{
50 pub fn new() -> Self {
52 Self::from_vec(Vec::new())
53 }
54
55 pub fn with_capacity(capacity: usize) -> Self {
57 Self::from_vec(Vec::with_capacity(capacity))
58 }
59
60 pub fn with_children(
62 children: impl IntoIterator<Item = Element<'a, Message, Theme, Renderer>>,
63 ) -> Self {
64 let iterator = children.into_iter();
65
66 Self::with_capacity(iterator.size_hint().0).extend(iterator)
67 }
68
69 pub fn from_vec(
77 children: Vec<Element<'a, Message, Theme, Renderer>>,
78 ) -> Self {
79 Self {
80 spacing: 0.0,
81 padding: Padding::ZERO,
82 width: Length::Shrink,
83 height: Length::Shrink,
84 align: Alignment::Start,
85 clip: false,
86 children,
87 }
88 }
89
90 pub fn spacing(mut self, amount: impl Into<Pixels>) -> Self {
96 self.spacing = amount.into().0;
97 self
98 }
99
100 pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
102 self.padding = padding.into();
103 self
104 }
105
106 pub fn width(mut self, width: impl Into<Length>) -> Self {
108 self.width = width.into();
109 self
110 }
111
112 pub fn height(mut self, height: impl Into<Length>) -> Self {
114 self.height = height.into();
115 self
116 }
117
118 pub fn align_y(mut self, align: impl Into<alignment::Vertical>) -> Self {
120 self.align = Alignment::from(align.into());
121 self
122 }
123
124 pub fn clip(mut self, clip: bool) -> Self {
127 self.clip = clip;
128 self
129 }
130
131 pub fn push(
133 mut self,
134 child: impl Into<Element<'a, Message, Theme, Renderer>>,
135 ) -> Self {
136 let child = child.into();
137 let child_size = child.as_widget().size_hint();
138
139 self.width = self.width.enclose(child_size.width);
140 self.height = self.height.enclose(child_size.height);
141
142 self.children.push(child);
143 self
144 }
145
146 pub fn push_maybe(
148 self,
149 child: Option<impl Into<Element<'a, Message, Theme, Renderer>>>,
150 ) -> Self {
151 if let Some(child) = child {
152 self.push(child)
153 } else {
154 self
155 }
156 }
157
158 pub fn extend(
160 self,
161 children: impl IntoIterator<Item = Element<'a, Message, Theme, Renderer>>,
162 ) -> Self {
163 children.into_iter().fold(self, Self::push)
164 }
165
166 pub fn wrap(self) -> Wrapping<'a, Message, Theme, Renderer> {
170 Wrapping { row: self }
171 }
172}
173
174impl<Message, Renderer> Default for Row<'_, Message, Renderer>
175where
176 Renderer: crate::core::Renderer,
177{
178 fn default() -> Self {
179 Self::new()
180 }
181}
182
183impl<'a, Message, Theme, Renderer: crate::core::Renderer>
184 FromIterator<Element<'a, Message, Theme, Renderer>>
185 for Row<'a, Message, Theme, Renderer>
186{
187 fn from_iter<
188 T: IntoIterator<Item = Element<'a, Message, Theme, Renderer>>,
189 >(
190 iter: T,
191 ) -> Self {
192 Self::with_children(iter)
193 }
194}
195
196impl<Message, Theme, Renderer> Widget<Message, Theme, Renderer>
197 for Row<'_, Message, Theme, Renderer>
198where
199 Renderer: crate::core::Renderer,
200{
201 fn children(&self) -> Vec<Tree> {
202 self.children.iter().map(Tree::new).collect()
203 }
204
205 fn diff(&self, tree: &mut Tree) {
206 tree.diff_children(&self.children);
207 }
208
209 fn size(&self) -> Size<Length> {
210 Size {
211 width: self.width,
212 height: self.height,
213 }
214 }
215
216 fn layout(
217 &self,
218 tree: &mut Tree,
219 renderer: &Renderer,
220 limits: &layout::Limits,
221 ) -> layout::Node {
222 layout::flex::resolve(
223 layout::flex::Axis::Horizontal,
224 renderer,
225 limits,
226 self.width,
227 self.height,
228 self.padding,
229 self.spacing,
230 self.align,
231 &self.children,
232 &mut tree.children,
233 )
234 }
235
236 fn operate(
237 &self,
238 tree: &mut Tree,
239 layout: Layout<'_>,
240 renderer: &Renderer,
241 operation: &mut dyn Operation,
242 ) {
243 operation.container(None, layout.bounds(), &mut |operation| {
244 self.children
245 .iter()
246 .zip(&mut tree.children)
247 .zip(layout.children())
248 .for_each(|((child, state), layout)| {
249 child
250 .as_widget()
251 .operate(state, layout, renderer, operation);
252 });
253 });
254 }
255
256 fn update(
257 &mut self,
258 tree: &mut Tree,
259 event: &Event,
260 layout: Layout<'_>,
261 cursor: mouse::Cursor,
262 renderer: &Renderer,
263 clipboard: &mut dyn Clipboard,
264 shell: &mut Shell<'_, Message>,
265 viewport: &Rectangle,
266 ) {
267 for ((child, state), layout) in self
268 .children
269 .iter_mut()
270 .zip(&mut tree.children)
271 .zip(layout.children())
272 {
273 child.as_widget_mut().update(
274 state, event, layout, cursor, renderer, clipboard, shell,
275 viewport,
276 );
277 }
278 }
279
280 fn mouse_interaction(
281 &self,
282 tree: &Tree,
283 layout: Layout<'_>,
284 cursor: mouse::Cursor,
285 viewport: &Rectangle,
286 renderer: &Renderer,
287 ) -> mouse::Interaction {
288 self.children
289 .iter()
290 .zip(&tree.children)
291 .zip(layout.children())
292 .map(|((child, state), layout)| {
293 child.as_widget().mouse_interaction(
294 state, layout, cursor, viewport, renderer,
295 )
296 })
297 .max()
298 .unwrap_or_default()
299 }
300
301 fn draw(
302 &self,
303 tree: &Tree,
304 renderer: &mut Renderer,
305 theme: &Theme,
306 style: &renderer::Style,
307 layout: Layout<'_>,
308 cursor: mouse::Cursor,
309 viewport: &Rectangle,
310 ) {
311 if let Some(clipped_viewport) = layout.bounds().intersection(viewport) {
312 let viewport = if self.clip {
313 &clipped_viewport
314 } else {
315 viewport
316 };
317
318 for ((child, state), layout) in self
319 .children
320 .iter()
321 .zip(&tree.children)
322 .zip(layout.children())
323 .filter(|(_, layout)| layout.bounds().intersects(viewport))
324 {
325 child.as_widget().draw(
326 state, renderer, theme, style, layout, cursor, viewport,
327 );
328 }
329 }
330 }
331
332 fn overlay<'b>(
333 &'b mut self,
334 tree: &'b mut Tree,
335 layout: Layout<'_>,
336 renderer: &Renderer,
337 translation: Vector,
338 ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
339 overlay::from_children(
340 &mut self.children,
341 tree,
342 layout,
343 renderer,
344 translation,
345 )
346 }
347}
348
349impl<'a, Message, Theme, Renderer> From<Row<'a, Message, Theme, Renderer>>
350 for Element<'a, Message, Theme, Renderer>
351where
352 Message: 'a,
353 Theme: 'a,
354 Renderer: crate::core::Renderer + 'a,
355{
356 fn from(row: Row<'a, Message, Theme, Renderer>) -> Self {
357 Self::new(row)
358 }
359}
360
361#[allow(missing_debug_implementations)]
368pub struct Wrapping<
369 'a,
370 Message,
371 Theme = crate::Theme,
372 Renderer = crate::Renderer,
373> {
374 row: Row<'a, Message, Theme, Renderer>,
375}
376
377impl<Message, Theme, Renderer> Widget<Message, Theme, Renderer>
378 for Wrapping<'_, Message, Theme, Renderer>
379where
380 Renderer: crate::core::Renderer,
381{
382 fn children(&self) -> Vec<Tree> {
383 self.row.children()
384 }
385
386 fn diff(&self, tree: &mut Tree) {
387 self.row.diff(tree);
388 }
389
390 fn size(&self) -> Size<Length> {
391 self.row.size()
392 }
393
394 fn layout(
395 &self,
396 tree: &mut Tree,
397 renderer: &Renderer,
398 limits: &layout::Limits,
399 ) -> layout::Node {
400 let limits = limits
401 .width(self.row.width)
402 .height(self.row.height)
403 .shrink(self.row.padding);
404
405 let spacing = self.row.spacing;
406 let max_width = limits.max().width;
407
408 let mut children: Vec<layout::Node> = Vec::new();
409 let mut intrinsic_size = Size::ZERO;
410 let mut row_start = 0;
411 let mut row_height = 0.0;
412 let mut x = 0.0;
413 let mut y = 0.0;
414
415 let align_factor = match self.row.align {
416 Alignment::Start => 0.0,
417 Alignment::Center => 2.0,
418 Alignment::End => 1.0,
419 };
420
421 let align = |row_start: std::ops::Range<usize>,
422 row_height: f32,
423 children: &mut Vec<layout::Node>| {
424 if align_factor != 0.0 {
425 for node in &mut children[row_start] {
426 let height = node.size().height;
427
428 node.translate_mut(Vector::new(
429 0.0,
430 (row_height - height) / align_factor,
431 ));
432 }
433 }
434 };
435
436 for (i, child) in self.row.children.iter().enumerate() {
437 let node = child.as_widget().layout(
438 &mut tree.children[i],
439 renderer,
440 &limits,
441 );
442
443 let child_size = node.size();
444
445 if x != 0.0 && x + child_size.width > max_width {
446 intrinsic_size.width = intrinsic_size.width.max(x - spacing);
447
448 align(row_start..i, row_height, &mut children);
449
450 y += row_height + spacing;
451 x = 0.0;
452 row_start = i;
453 row_height = 0.0;
454 }
455
456 row_height = row_height.max(child_size.height);
457
458 children.push(node.move_to((
459 x + self.row.padding.left,
460 y + self.row.padding.top,
461 )));
462
463 x += child_size.width + spacing;
464 }
465
466 if x != 0.0 {
467 intrinsic_size.width = intrinsic_size.width.max(x - spacing);
468 }
469
470 intrinsic_size.height = y + row_height;
471 align(row_start..children.len(), row_height, &mut children);
472
473 let size =
474 limits.resolve(self.row.width, self.row.height, intrinsic_size);
475
476 layout::Node::with_children(size.expand(self.row.padding), children)
477 }
478
479 fn operate(
480 &self,
481 tree: &mut Tree,
482 layout: Layout<'_>,
483 renderer: &Renderer,
484 operation: &mut dyn Operation,
485 ) {
486 self.row.operate(tree, layout, renderer, operation);
487 }
488
489 fn update(
490 &mut self,
491 tree: &mut Tree,
492 event: &Event,
493 layout: Layout<'_>,
494 cursor: mouse::Cursor,
495 renderer: &Renderer,
496 clipboard: &mut dyn Clipboard,
497 shell: &mut Shell<'_, Message>,
498 viewport: &Rectangle,
499 ) {
500 self.row.update(
501 tree, event, layout, cursor, renderer, clipboard, shell, viewport,
502 );
503 }
504
505 fn mouse_interaction(
506 &self,
507 tree: &Tree,
508 layout: Layout<'_>,
509 cursor: mouse::Cursor,
510 viewport: &Rectangle,
511 renderer: &Renderer,
512 ) -> mouse::Interaction {
513 self.row
514 .mouse_interaction(tree, layout, cursor, viewport, renderer)
515 }
516
517 fn draw(
518 &self,
519 tree: &Tree,
520 renderer: &mut Renderer,
521 theme: &Theme,
522 style: &renderer::Style,
523 layout: Layout<'_>,
524 cursor: mouse::Cursor,
525 viewport: &Rectangle,
526 ) {
527 self.row
528 .draw(tree, renderer, theme, style, layout, cursor, viewport);
529 }
530
531 fn overlay<'b>(
532 &'b mut self,
533 tree: &'b mut Tree,
534 layout: Layout<'_>,
535 renderer: &Renderer,
536 translation: Vector,
537 ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
538 self.row.overlay(tree, layout, renderer, translation)
539 }
540}
541
542impl<'a, Message, Theme, Renderer> From<Wrapping<'a, Message, Theme, Renderer>>
543 for Element<'a, Message, Theme, Renderer>
544where
545 Message: 'a,
546 Theme: 'a,
547 Renderer: crate::core::Renderer + 'a,
548{
549 fn from(row: Wrapping<'a, Message, Theme, Renderer>) -> Self {
550 Self::new(row)
551 }
552}