use super::shrink_sharing::share_within_order;
const DROP_TOLERANCE: f32 = 0.01;
#[derive(Clone, Copy)]
pub(super) struct ShrinkItem {
pub(super) factor: f32,
pub(super) natural: f32,
pub(super) floor: f32,
pub(super) order: i32,
pub(super) droppable: bool,
pub(super) drops_at_floor: bool,
pub(super) collapse: Option<Collapse>,
}
#[derive(Clone, Copy)]
pub(super) struct Collapse {
pub(super) natural: f32,
pub(super) floor: f32,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub(super) enum ShrinkOutcome {
Keep,
Resize(f32),
Collapsed(f32),
Drop,
}
#[derive(Clone, Copy)]
pub(super) struct LineSpace {
pub(super) overflow: f32,
pub(super) gap: f32,
pub(super) occupied: usize,
pub(super) whole_pixels: bool,
}
#[derive(Clone, Copy, PartialEq)]
enum Fate {
Stays,
Dropped,
Collapsed,
}
pub(super) fn distribute(items: &[ShrinkItem], space: LineSpace, collapsed: bool) -> Vec<ShrinkOutcome> {
let mut settled: Vec<Fate> = items
.iter()
.map(|item| match item {
_ if !collapsed => Fate::Stays,
ShrinkItem { droppable: true, .. }
| ShrinkItem {
drops_at_floor: true, ..
} => Fate::Dropped,
ShrinkItem { collapse: Some(_), .. } => Fate::Collapsed,
_ => Fate::Stays,
})
.collect();
loop {
let (outcomes, fates, overflow_left) = give_way_in_order(items, space, &settled);
if fates == settled || overflow_left >= -DROP_TOLERANCE {
return outcomes;
}
settled = fates;
}
}
fn collapsed(item: ShrinkItem) -> ShrinkItem {
match item.collapse {
Some(collapse) => ShrinkItem {
natural: collapse.natural,
floor: collapse.floor,
collapse: None,
..item
},
None => item,
}
}
fn give_way_in_order(items: &[ShrinkItem], space: LineSpace, settled: &[Fate]) -> (Vec<ShrinkOutcome>, Vec<Fate>, f32) {
let mut fates = settled.to_vec();
let mut shrinking_items: Vec<ShrinkItem> = items.to_vec();
let mut step = GiveWayStep {
overflow: space.overflow,
occupied: space.occupied,
gap: space.gap,
capacity: 0.0,
};
for index in 0..items.len() {
match fates[index] {
Fate::Stays => {}
Fate::Dropped => step.remove(items[index].natural),
Fate::Collapsed => {
shrinking_items[index] = collapsed(items[index]);
step.overflow -= items[index].natural - shrinking_items[index].natural;
}
}
}
let mut orders: Vec<i32> = (0..items.len())
.filter(|&index| fates[index] != Fate::Dropped)
.map(|index| items[index].order)
.collect();
orders.sort_unstable();
orders.dedup();
let mut outcomes = vec![ShrinkOutcome::Keep; items.len()];
for order in orders {
if step.overflow <= 0.0 {
break;
}
let members: Vec<usize> = (0..items.len())
.filter(|&index| fates[index] != Fate::Dropped && items[index].order == order)
.collect();
let shrinking = give_way_whole(items, &members, &mut shrinking_items, &mut fates, &mut step);
if step.overflow <= 0.0 {
break;
}
step.overflow = share_within_order(
&shrinking_items,
&shrinking,
step.overflow,
space.whole_pixels,
&mut outcomes,
);
}
for (index, fate) in fates.iter().enumerate() {
outcomes[index] = match (fate, outcomes[index]) {
(Fate::Dropped, _) => ShrinkOutcome::Drop,
(Fate::Collapsed, ShrinkOutcome::Resize(size)) => ShrinkOutcome::Collapsed(size),
(Fate::Collapsed, _) => ShrinkOutcome::Collapsed(shrinking_items[index].natural),
(Fate::Stays, outcome) => outcome,
};
}
(outcomes, fates, step.overflow)
}
fn give_way_whole(
items: &[ShrinkItem],
members: &[usize],
shrinking_items: &mut [ShrinkItem],
fates: &mut [Fate],
step: &mut GiveWayStep,
) -> Vec<usize> {
let (mut shrinking, droppable): (Vec<usize>, Vec<usize>) =
members.iter().copied().partition(|&index| !items[index].droppable);
let room = |item: ShrinkItem| item.natural - item.floor;
step.capacity = shrinking.iter().map(|&index| room(shrinking_items[index])).sum();
for &index in droppable.iter().rev() {
if !step.needs_more() {
return shrinking;
}
step.remove(items[index].natural);
fates[index] = Fate::Dropped;
}
let below: Vec<usize> = shrinking
.iter()
.copied()
.filter(|&index| items[index].drops_at_floor)
.collect();
for &index in below.iter().rev() {
if !step.needs_more() {
return shrinking;
}
step.remove(items[index].natural);
step.capacity -= room(shrinking_items[index]);
fates[index] = Fate::Dropped;
shrinking.retain(|&kept| kept != index);
}
let collapsing: Vec<usize> = shrinking
.iter()
.copied()
.filter(|&index| items[index].collapse.is_some() && fates[index] == Fate::Stays)
.collect();
for &index in collapsing.iter().rev() {
if !step.needs_more() {
return shrinking;
}
let before = shrinking_items[index];
shrinking_items[index] = collapsed(before);
step.overflow -= before.natural - shrinking_items[index].natural;
step.capacity += room(shrinking_items[index]) - room(before);
fates[index] = Fate::Collapsed;
}
shrinking
}
struct GiveWayStep {
overflow: f32,
occupied: usize,
gap: f32,
capacity: f32,
}
impl GiveWayStep {
fn needs_more(&self) -> bool {
self.overflow > self.capacity + DROP_TOLERANCE
}
fn remove(&mut self, natural: f32) {
self.overflow -= natural + if self.occupied > 1 { self.gap } else { 0.0 };
self.occupied -= 1;
}
}