123 lines
3.5 KiB
Rust
123 lines
3.5 KiB
Rust
use crate::unit::{Rect, Size};
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum LayoutItem {
|
|
Rows { unit: Size, items: Vec<LayoutItem> },
|
|
SpacedRows { unit: Size, items: Vec<LayoutItem> },
|
|
|
|
Columns { unit: Size, items: Vec<LayoutItem> },
|
|
SpacedColumns { unit: Size, items: Vec<LayoutItem> },
|
|
|
|
Frame { padding: u16, item: Box<LayoutItem> },
|
|
Widget(Size),
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Allocation {
|
|
pub widgets: Vec<Rect>,
|
|
pub frame: Vec<Rect>,
|
|
}
|
|
|
|
impl LayoutItem {
|
|
pub fn allocate(&self, alloc: &Rect, full_alloc: &mut Allocation) {
|
|
match self {
|
|
Self::Rows { items, .. }
|
|
| Self::Columns { items, .. }
|
|
| Self::SpacedRows { items, .. }
|
|
| Self::SpacedColumns { items, .. } => {
|
|
full_alloc.frame.push(*alloc);
|
|
|
|
let is_row = matches!(self, Self::Rows { .. });
|
|
|
|
let allocation = if is_row { alloc.height } else { alloc.width };
|
|
|
|
let remaining = allocation
|
|
- items
|
|
.iter()
|
|
.map(|item| item.get_size().get_fixed(alloc.height))
|
|
.sum::<u16>();
|
|
|
|
let total_weight = items
|
|
.iter()
|
|
.map(|item| item.get_size().get_flex())
|
|
.sum::<u16>();
|
|
|
|
let mut curr = if is_row { alloc.y } else { alloc.x };
|
|
|
|
for item in items {
|
|
let size = item.get_size();
|
|
|
|
let unit_alloc = size.get(allocation, remaining, total_weight);
|
|
|
|
let item_alloc = if is_row {
|
|
Rect {
|
|
width: alloc.width,
|
|
height: unit_alloc,
|
|
x: alloc.x,
|
|
y: curr,
|
|
}
|
|
} else {
|
|
Rect {
|
|
width: unit_alloc,
|
|
height: alloc.height,
|
|
x: curr,
|
|
y: alloc.y,
|
|
}
|
|
};
|
|
|
|
curr += unit_alloc;
|
|
|
|
item.allocate(&item_alloc, full_alloc);
|
|
}
|
|
}
|
|
|
|
Self::Frame { padding, item } => {
|
|
full_alloc.frame.push(*alloc);
|
|
|
|
let mut item_alloc = alloc.clone();
|
|
|
|
item_alloc.width -= padding * 2;
|
|
item_alloc.height -= padding * 2;
|
|
|
|
item_alloc.x += padding;
|
|
item_alloc.y += padding;
|
|
|
|
item.allocate(&item_alloc, full_alloc);
|
|
}
|
|
|
|
Self::Widget(_) => {
|
|
full_alloc.widgets.push(*alloc);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn get_size<'a>(&'a self) -> &'a Size {
|
|
match self {
|
|
Self::Rows { unit, .. } | Self::SpacedRows { unit, .. } => unit,
|
|
Self::Columns { unit, .. } | Self::SpacedColumns { unit, .. } => unit,
|
|
Self::Widget(unit) => unit,
|
|
Self::Frame { item, .. } => item.get_size(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Rect {
|
|
pub fn allocate(&self, layout: &LayoutItem) -> Allocation {
|
|
let mut alloc = Allocation {
|
|
widgets: Vec::new(),
|
|
frame: Vec::new(),
|
|
};
|
|
|
|
layout.allocate(self, &mut alloc);
|
|
|
|
alloc
|
|
}
|
|
}
|
|
|
|
pub fn layout(rows: Vec<LayoutItem>) -> LayoutItem {
|
|
LayoutItem::Columns {
|
|
unit: Size::Percent(100),
|
|
items: rows,
|
|
}
|
|
}
|