summaryrefslogtreecommitdiff
path: root/src/layout
diff options
context:
space:
mode:
Diffstat (limited to 'src/layout')
-rw-r--r--src/layout/frame.rs8
-rw-r--r--src/layout/grid.rs398
-rw-r--r--src/layout/stack.rs165
3 files changed, 288 insertions, 283 deletions
diff --git a/src/layout/frame.rs b/src/layout/frame.rs
index f1dc07e6..6cecc7a3 100644
--- a/src/layout/frame.rs
+++ b/src/layout/frame.rs
@@ -35,14 +35,6 @@ impl Frame {
self.push(pos + subpos, element);
}
}
-
- /// Translate the positions of all elements in the frame by adding the
- /// argument to their position.
- pub fn translate(&mut self, amount: Point) {
- for (pos, _) in &mut self.elements {
- *pos += amount;
- }
- }
}
/// The building block frames are composed of.
diff --git a/src/layout/grid.rs b/src/layout/grid.rs
index 9c4c2e0e..3ba6c16b 100644
--- a/src/layout/grid.rs
+++ b/src/layout/grid.rs
@@ -1,216 +1,128 @@
-use std::usize;
-
use super::*;
-use crate::library::GridUnits;
-/// A node that stacks its children.
+/// A node that arranges its children in a grid.
#[derive(Debug, Clone, PartialEq, Hash)]
pub struct GridNode {
- /// The `main` and `cross` directions of this stack.
- ///
- /// The children are stacked along the `main` direction. The `cross`
- /// direction is required for aligning the children.
- pub dir: Dir,
- /// The nodes to be stacked.
+ /// The column (cross) direction of this stack.
+ pub column_dir: Dir,
+ /// The nodes to be arranged in a grid.
pub children: Vec<AnyNode>,
- pub tracks: Gen<GridUnits>,
- pub gutter: Gen<GridUnits>,
+ /// Defines sizing for rows and columns.
+ pub tracks: Gen<Tracks>,
+ /// Defines sizing of the gutter between rows and columns.
+ pub gutter: Gen<Tracks>,
}
impl Layout for GridNode {
fn layout(&self, ctx: &mut LayoutContext, regions: &Regions) -> Vec<Frame> {
- let layout = GridLayouter::new(self, regions).layout(ctx);
- layout
+ GridLayouter::new(self, regions.clone()).layout(ctx)
}
}
-#[derive(Debug)]
-enum GridItem<'a> {
- Node(&'a AnyNode),
- Gutter,
+impl From<GridNode> for AnyNode {
+ fn from(grid: GridNode) -> Self {
+ Self::new(grid)
+ }
}
-#[derive(Debug)]
struct GridLayouter<'a> {
- items: Vec<GridItem<'a>>,
+ cross: SpecAxis,
+ main: SpecAxis,
cols: Vec<TrackSizing>,
rows: Vec<TrackSizing>,
- region: Regions,
- dir: Dir,
+ cells: Vec<Cell<'a>>,
+ regions: Regions,
rrows: Vec<(usize, Option<Length>)>,
rcols: Vec<Length>,
- frames: Vec<Frame>,
+ finished: Vec<Frame>,
+}
+
+enum Cell<'a> {
+ Node(&'a AnyNode),
+ Gutter,
}
impl<'a> GridLayouter<'a> {
- fn new(
- grid: &'a GridNode,
- regions: &Regions,
- ) -> Self {
- let mut items = vec![];
+ fn new(grid: &'a GridNode, regions: Regions) -> Self {
let mut col_sizes = vec![];
let mut row_sizes = vec![];
- let cols = grid.tracks.cross.0.len();
- // Create at least as many rows as specified and a row to fit every item.
- let rows = if cols > 0 {
- let res = grid
- .tracks
- .main
- .0
- .len()
- .max(grid.children.len() / cols + (grid.children.len() % cols).clamp(0, 1));
- res
- } else {
- 0
+ let mut cells = vec![];
+
+ // A grid always needs to have at least one column.
+ let cols = grid.tracks.cross.0.len().max(1);
+
+ // Create at least as many rows as specified and also at least as many
+ // as necessary to place each item.
+ let rows = {
+ let len = grid.children.len();
+ let specified = grid.tracks.main.0.len();
+ let necessary = len / cols + (len % cols).clamp(0, 1);
+ specified.max(necessary)
};
- for (i, col_size) in grid.tracks.cross.0.iter().enumerate() {
- let last = i == cols - 1;
- col_sizes.push(*col_size);
-
- if !last {
- let gutter = grid.gutter.cross.get(i);
- col_sizes.push(gutter);
+ // Collect the track sizing for all columns, including gutter columns.
+ for i in 0 .. cols {
+ col_sizes.push(grid.tracks.cross.get(i));
+ if i < cols - 1 {
+ col_sizes.push(grid.gutter.cross.get(i));
}
}
- for (i, row_size) in (0 .. rows).map(|i| (i, grid.tracks.main.get(i))) {
- let last = i == rows - 1;
- row_sizes.push(row_size);
-
- if !last {
- let gutter = grid.gutter.main.get(i);
- row_sizes.push(gutter);
+ // Collect the track sizing for all rows, including gutter rows.
+ for i in 0 .. rows {
+ row_sizes.push(grid.tracks.main.get(i));
+ if i < rows - 1 {
+ row_sizes.push(grid.gutter.main.get(i));
}
}
+ // Build up the matrix of cells, including gutter cells.
for (i, item) in grid.children.iter().enumerate() {
- if cols == 0 {
- break;
- }
+ cells.push(Cell::Node(item));
let row = i / cols;
let col = i % cols;
- items.push(GridItem::Node(item));
-
- if col != cols - 1 {
- // Push gutter
- items.push(GridItem::Gutter);
- } else if row != rows - 1 {
- // Push gutter row.
+ if col < cols - 1 {
+ // Push gutter after each child.
+ cells.push(Cell::Gutter);
+ } else if row < rows - 1 {
+ // Except for the last child of each row.
+ // There we push a gutter row.
for _ in 0 .. col_sizes.len() {
- items.push(GridItem::Gutter);
+ cells.push(Cell::Gutter);
}
}
}
- // Fill the thing up
- while items.len() < col_sizes.len() * row_sizes.len() {
- items.push(GridItem::Gutter)
+ // Fill the thing up.
+ while cells.len() < col_sizes.len() * row_sizes.len() {
+ cells.push(Cell::Gutter)
}
- GridLayouter {
+ Self {
+ cross: grid.column_dir.axis(),
+ main: grid.column_dir.axis().other(),
cols: col_sizes,
rows: row_sizes,
- region: regions.clone(),
- dir: grid.dir,
- items,
+ cells,
+ regions,
rrows: vec![],
rcols: vec![],
- frames: vec![],
- }
- }
-
- fn get(&self, x: usize, y: usize) -> &GridItem<'_> {
- assert!(x < self.cols.len());
- assert!(y < self.rows.len());
- let row_cmp = y * self.cols.len();
-
- self.items.get(row_cmp + x).unwrap()
- }
-
- fn main(&self) -> SpecAxis {
- self.dir.axis().other()
- }
-
- fn cross(&self) -> SpecAxis {
- self.dir.axis()
- }
-
- fn finish_region(&mut self, ctx: &mut LayoutContext, total_frs: f64) {
- let mut pos = Gen::splat(Length::zero());
- let pos2point = |mut pos: Gen<Length>| {
- if !self.dir.is_positive() {
- pos.cross = -pos.cross;
- }
- pos.switch(self.main()).to_point()
- };
- let mut frame = Frame::new(Size::zero(), Length::zero());
- let mut total_cross = Length::zero();
- let mut total_main = Length::zero();
-
- for (x, &w) in self.rcols.iter().enumerate() {
- let total: Length = self.rrows.iter().filter_map(|(_, x)| *x).sum();
- let available = self.region.current.get(self.main()) - total;
- total_cross += w;
-
- for (y, h) in self.rrows.iter() {
- let element = self.get(x, *y);
- let h = if let Some(len) = h {
- *len
- } else {
- if let TrackSizing::Fractional(f) = self.rows[*y] {
- if total_frs > 0.0 {
- let res = available * (f.get() / total_frs);
- if res.is_finite() {
- res
- } else {
- Length::zero()
- }
- } else {
- Length::zero()
- }
- } else {
- unreachable!()
- }
- };
- if x == 0 {
- total_main += h;
- }
-
- if let GridItem::Node(n) = element {
- let item = n.layout(ctx, &Regions::one(Gen::new(w, h).switch(self.main()).to_size(), Spec::splat(false))).remove(0);
- frame.push_frame(pos2point(pos), item);
- }
-
- pos.main += h;
- }
- pos.main = Length::zero();
- pos.cross += self.dir.factor() as f64 * w;
+ finished: vec![],
}
-
- if !self.dir.is_positive() {
- frame.translate(Gen::new(total_cross, Length::zero()).switch(self.main()).to_point());
- }
-
- frame.size = Gen::new(total_cross, total_main).switch(self.main()).to_size();
- frame.baseline = frame.size.height;
-
- self.frames.push(frame);
-
- self.rrows.clear();
- self.region.next();
}
fn layout(mut self, ctx: &mut LayoutContext) -> Vec<Frame> {
// Shrink area by linear sizing.
- let mut available = self.region.current.get(self.cross());
+ let mut available = self.regions.current.get(self.cross);
available -= self
.cols
.iter()
.filter_map(|x| match x {
- TrackSizing::Linear(l) => Some(l.resolve(self.region.base.get(self.cross()))),
+ TrackSizing::Linear(l) => {
+ Some(l.resolve(self.regions.base.get(self.cross)))
+ }
_ => None,
})
.sum();
@@ -232,34 +144,31 @@ impl<'a> GridLayouter<'a> {
let mut col_width = vec![];
- // For each of the auto columns, lay out all elements with `preliminary_length`
- // rows and build max.
+ // For each of the auto columns, lay out all elements with
+ // `preliminary_length` rows and build max.
for x in auto_columns {
let mut max = Length::zero();
- for (y, row_height) in
- self.rows.iter().enumerate().map(|(y, s)| {
- (y, s.preliminary_length(self.region.base.get(self.main())))
- })
- {
- let item = self.get(x, y);
- let size =
- Gen::new(self.region.current.get(self.cross()), row_height).switch(self.main()).to_size();
+
+ for (y, row) in self.rows.iter().enumerate() {
+ let mut size = self.regions.current;
+ if let TrackSizing::Linear(l) = row {
+ *size.get_mut(self.main) =
+ l.resolve(self.regions.base.get(self.main));
+ }
+
let region = Regions::one(size, Spec::splat(false));
- match item {
- GridItem::Node(n) => {
- max = max.max(
- n.layout(ctx, &region).first().unwrap().size.get(self.cross()),
- )
- }
- GridItem::Gutter => {}
+ if let Cell::Node(node) = self.get(x, y) {
+ let frame = node.layout(ctx, &region).remove(0);
+ max = max.max(frame.size.get(self.cross))
}
}
col_width.push((x, max));
}
- // If accumulated auto column size exceeds available size, redistribute space
- // proportionally amongst elements that exceed their size allocation.
+ // If accumulated auto column size exceeds available size, redistribute
+ // space proportionally amongst elements that exceed their size
+ // allocation.
let mut total: Length = col_width.iter().map(|(_, x)| *x).sum();
if total > available {
let alloc = available / col_width.len() as f64;
@@ -288,23 +197,25 @@ impl<'a> GridLayouter<'a> {
}
// Build rcols
- for (x, len) in col_width.into_iter().map(|(x, s)| (x, Some(s))).chain(std::iter::once((self.cols.len(), None))) {
+ for (x, len) in col_width
+ .into_iter()
+ .map(|(x, s)| (x, Some(s)))
+ .chain(std::iter::once((self.cols.len(), None)))
+ {
for i in self.rcols.len() .. x {
let len = match self.cols[i] {
- TrackSizing::Linear(l) => l.resolve(self.region.base.get(self.cross())),
+ TrackSizing::Linear(l) => {
+ l.resolve(self.regions.base.get(self.cross))
+ }
TrackSizing::Fractional(f) => {
if col_frac == 0.0 {
Length::zero()
} else {
let res: Length = (available - total) * (f.get() / col_frac);
- if res.is_finite() {
- res
- } else {
- Length::zero()
- }
+ if res.is_finite() { res } else { Length::zero() }
}
}
- TrackSizing::Auto => unreachable!(),
+ TrackSizing::Auto => unreachable!("x is an auto track"),
};
self.rcols.push(len);
@@ -317,27 +228,23 @@ impl<'a> GridLayouter<'a> {
// Determine non-`fr` row heights
let mut total_frs = 0.0;
- let mut current = self.region.current.get(self.main());
+ let mut current = self.regions.current.get(self.main);
- for y in 0..self.rows.len() {
- let height = &self.rows[y];
- let resolved = match height {
- TrackSizing::Linear(l) => Some(l.resolve(self.region.base.get(self.main()))),
+ for y in 0 .. self.rows.len() {
+ let resolved = match self.rows[y] {
+ TrackSizing::Linear(l) => {
+ Some(l.resolve(self.regions.base.get(self.main)))
+ }
TrackSizing::Auto => {
let mut max = Length::zero();
for (x, len) in self.rcols.iter().enumerate() {
- let node = self.get(x, y);
- if let GridItem::Node(node) = node {
- let frames = node.layout(
- ctx,
- &Regions::one(
- Gen::new(*len, current)
- .switch(self.main())
- .to_size(),
- Spec::splat(false),
- ),
+ if let Cell::Node(node) = self.get(x, y) {
+ let regions = Regions::one(
+ Gen::new(*len, current).to_size(self.main),
+ Spec::splat(false),
);
- max = max.max(frames.first().unwrap().size.get(self.main()));
+ let frame = node.layout(ctx, &regions).remove(0);
+ max = max.max(frame.size.get(self.main));
}
}
Some(max)
@@ -345,13 +252,13 @@ impl<'a> GridLayouter<'a> {
TrackSizing::Fractional(f) => {
total_frs += f.get();
None
- },
+ }
};
if let Some(resolved) = resolved {
- while !current.fits(resolved) && !self.region.in_full_last() {
+ while !current.fits(resolved) && !self.regions.in_full_last() {
self.finish_region(ctx, total_frs);
- current = self.region.current.get(self.main());
+ current = self.regions.current.get(self.main);
total_frs = 0.0;
}
current -= resolved;
@@ -361,12 +268,91 @@ impl<'a> GridLayouter<'a> {
}
self.finish_region(ctx, total_frs);
- self.frames
+ self.finished
+ }
+
+ fn finish_region(&mut self, ctx: &mut LayoutContext, total_frs: f64) {
+ let mut pos = Gen::splat(Length::zero());
+ let mut frame = Frame::new(Size::zero(), Length::zero());
+ let mut total_cross = Length::zero();
+ let mut total_main = Length::zero();
+
+ for (x, &w) in self.rcols.iter().enumerate() {
+ let total: Length = self.rrows.iter().filter_map(|(_, x)| *x).sum();
+ let available = self.regions.current.get(self.main) - total;
+ total_cross += w;
+
+ for (y, h) in self.rrows.iter() {
+ let element = self.get(x, *y);
+ let h = if let Some(len) = h {
+ *len
+ } else if let TrackSizing::Fractional(f) = self.rows[*y] {
+ if total_frs > 0.0 {
+ let res = available * (f.get() / total_frs);
+ if res.is_finite() { res } else { Length::zero() }
+ } else {
+ Length::zero()
+ }
+ } else {
+ unreachable!("non-fractional tracks are already resolved");
+ };
+
+ if x == 0 {
+ total_main += h;
+ }
+
+ if let Cell::Node(n) = element {
+ let regions = Regions::one(
+ Gen::new(w, h).to_size(self.main),
+ Spec::splat(false),
+ );
+ let item = n.layout(ctx, &regions).remove(0);
+ frame.push_frame(pos.to_point(self.main), item);
+ }
+
+ pos.main += h;
+ }
+ pos.main = Length::zero();
+ pos.cross += w;
+ }
+
+ frame.size = Gen::new(total_cross, total_main).to_size(self.main);
+ frame.baseline = frame.size.height;
+
+ self.rrows.clear();
+ self.regions.next();
+ self.finished.push(frame);
+ }
+
+ fn get(&self, x: usize, y: usize) -> &Cell<'a> {
+ assert!(x < self.cols.len());
+ assert!(y < self.rows.len());
+ self.cells.get(y * self.cols.len() + x).unwrap()
}
}
-impl From<GridNode> for AnyNode {
- fn from(grid: GridNode) -> Self {
- Self::new(grid)
+/// A list of track sizing definitions.
+#[derive(Default, Debug, Clone, PartialEq, Hash)]
+pub struct Tracks(pub Vec<TrackSizing>);
+
+impl Tracks {
+ /// Get the sizing for the track at the given `idx`.
+ fn get(&self, idx: usize) -> TrackSizing {
+ self.0
+ .get(idx)
+ .or(self.0.last())
+ .copied()
+ .unwrap_or(TrackSizing::Auto)
}
}
+
+/// Defines how to size a grid cell along an axis.
+#[derive(Debug, Copy, Clone, PartialEq, Hash)]
+pub enum TrackSizing {
+ /// Fit the cell to its contents.
+ Auto,
+ /// A length stated in absolute values and fractions of the parent's size.
+ Linear(Linear),
+ /// A length that is the fraction of the remaining free space in the parent.
+ Fractional(Fractional),
+}
diff --git a/src/layout/stack.rs b/src/layout/stack.rs
index 410f53c6..e4c0708d 100644
--- a/src/layout/stack.rs
+++ b/src/layout/stack.rs
@@ -29,24 +29,7 @@ pub enum StackChild {
impl Layout for StackNode {
fn layout(&self, ctx: &mut LayoutContext, regions: &Regions) -> Vec<Frame> {
- let mut layouter = StackLayouter::new(self.dirs, self.aspect, regions.clone());
- for child in &self.children {
- match *child {
- StackChild::Spacing(amount) => layouter.push_spacing(amount),
- StackChild::Any(ref node, aligns) => {
- let mut frames = node.layout(ctx, &layouter.regions).into_iter();
- if let Some(frame) = frames.next() {
- layouter.push_frame(frame, aligns);
- }
-
- for frame in frames {
- layouter.finish_region();
- layouter.push_frame(frame, aligns);
- }
- }
- }
- }
- layouter.finish()
+ StackLayouter::new(self, regions.clone()).layout(ctx)
}
}
@@ -56,107 +39,154 @@ impl From<StackNode> for AnyNode {
}
}
-struct StackLayouter {
- dirs: Gen<Dir>,
- aspect: Option<N64>,
+struct StackLayouter<'a> {
+ /// The directions of the stack.
+ stack: &'a StackNode,
+ /// The axis of the main direction.
main: SpecAxis,
+ /// The region to layout into.
regions: Regions,
- finished: Vec<Frame>,
- frames: Vec<(Length, Frame, Gen<Align>)>,
+ /// Offset, alignment and frame for all children that fit into the current
+ /// region. The exact positions are not known yet.
+ frames: Vec<(Length, Gen<Align>, Frame)>,
+ /// The full size of `regions.current` that was available before we started
+ /// subtracting.
full: Size,
- size: Gen<Length>,
+ /// The generic size used by the frames for the current region.
+ used: Gen<Length>,
+ /// The alignment ruler for the current region.
ruler: Align,
+ /// Finished frames for previous regions.
+ finished: Vec<Frame>,
}
-impl StackLayouter {
- fn new(dirs: Gen<Dir>, aspect: Option<N64>, mut regions: Regions) -> Self {
- if let Some(aspect) = aspect {
+impl<'a> StackLayouter<'a> {
+ fn new(stack: &'a StackNode, mut regions: Regions) -> Self {
+ if let Some(aspect) = stack.aspect {
regions.apply_aspect_ratio(aspect);
}
Self {
- dirs,
- aspect,
- main: dirs.main.axis(),
+ stack,
+ main: stack.dirs.main.axis(),
finished: vec![],
frames: vec![],
full: regions.current,
- size: Gen::zero(),
+ used: Gen::zero(),
ruler: Align::Start,
regions,
}
}
+ fn layout(mut self, ctx: &mut LayoutContext) -> Vec<Frame> {
+ for child in &self.stack.children {
+ match *child {
+ StackChild::Spacing(amount) => self.push_spacing(amount),
+ StackChild::Any(ref node, aligns) => {
+ let mut frames = node.layout(ctx, &self.regions).into_iter();
+ if let Some(frame) = frames.next() {
+ self.push_frame(frame, aligns);
+ }
+
+ for frame in frames {
+ self.finish_region();
+ self.push_frame(frame, aligns);
+ }
+ }
+ }
+ }
+
+ self.finish_region();
+ self.finished
+ }
+
fn push_spacing(&mut self, amount: Length) {
+ // Cap the spacing to the remaining available space.
let remaining = self.regions.current.get_mut(self.main);
let capped = amount.min(*remaining);
+
+ // Grow our size and shrink the available space in the region.
+ self.used.main += capped;
*remaining -= capped;
- self.size.main += capped;
}
fn push_frame(&mut self, frame: Frame, aligns: Gen<Align>) {
+ let size = frame.size;
+
+ // Don't allow `Start` after `End` in the same region.
if self.ruler > aligns.main {
self.finish_region();
}
- while !self.regions.current.fits(frame.size) && !self.regions.in_full_last() {
+ // Adjust the ruler.
+ self.ruler = aligns.main;
+
+ // Find a fitting region.
+ while !self.regions.current.fits(size) && !self.regions.in_full_last() {
self.finish_region();
}
- let offset = self.size.main;
- let size = frame.size.switch(self.main);
- self.size.main += size.main;
- self.size.cross.set_max(size.cross);
- self.ruler = aligns.main;
- *self.regions.current.get_mut(self.main) -= size.main;
- self.frames.push((offset, frame, aligns));
+ // Remember the frame with offset and alignment.
+ self.frames.push((self.used.main, aligns, frame));
+
+ // Grow our size and shrink available space in the region.
+ let gen = size.to_gen(self.main);
+ self.used.main += gen.main;
+ self.used.cross.set_max(gen.cross);
+ *self.regions.current.get_mut(self.main) -= gen.main;
}
fn finish_region(&mut self) {
+ let used = self.used.to_size(self.main);
let fixed = self.regions.fixed;
- let used = self.size.switch(self.main).to_size();
- let mut size = Size::new(
+ // Determine the stack's size dependening on whether the region is
+ // fixed.
+ let mut stack_size = Size::new(
if fixed.horizontal { self.full.width } else { used.width },
if fixed.vertical { self.full.height } else { used.height },
);
- if let Some(aspect) = self.aspect {
- let width = size
+ // Make sure the stack's size satisfies the aspect ratio.
+ if let Some(aspect) = self.stack.aspect {
+ let width = stack_size
.width
- .max(aspect.into_inner() * size.height)
+ .max(aspect.into_inner() * stack_size.height)
.min(self.full.width)
.min(aspect.into_inner() * self.full.height);
- size = Size::new(width, width / aspect.into_inner());
+ stack_size = Size::new(width, width / aspect.into_inner());
}
- let mut output = Frame::new(size, size.height);
+ let mut output = Frame::new(stack_size, stack_size.height);
let mut first = true;
- let used = self.size;
- let size = size.switch(self.main);
-
- for (offset, frame, aligns) in std::mem::take(&mut self.frames) {
- let child = frame.size.switch(self.main);
+ // Place all frames.
+ for (offset, aligns, frame) in std::mem::take(&mut self.frames) {
+ let stack_size = stack_size.to_gen(self.main);
+ let child_size = frame.size.to_gen(self.main);
// Align along the cross axis.
- let cross = aligns
- .cross
- .resolve(self.dirs.cross, Length::zero() .. size.cross - child.cross);
+ let cross = aligns.cross.resolve(
+ self.stack.dirs.cross,
+ Length::zero() .. stack_size.cross - child_size.cross,
+ );
// Align along the main axis.
let main = aligns.main.resolve(
- self.dirs.main,
- if self.dirs.main.is_positive() {
- offset .. size.main - used.main + offset
+ self.stack.dirs.main,
+ if self.stack.dirs.main.is_positive() {
+ offset .. stack_size.main - self.used.main + offset
} else {
- let offset_with_self = offset + child.main;
- used.main - offset_with_self .. size.main - offset_with_self
+ let offset_with_self = offset + child_size.main;
+ self.used.main - offset_with_self
+ .. stack_size.main - offset_with_self
},
);
- let pos = Gen::new(cross, main).switch(self.main).to_point();
+ let pos = Gen::new(cross, main).to_point(self.main);
+
+ // The baseline of the stack is that of the first frame.
if first {
output.baseline = pos.y + frame.baseline;
first = false;
@@ -165,18 +195,15 @@ impl StackLayouter {
output.push_frame(pos, frame);
}
- self.size = Gen::zero();
- self.ruler = Align::Start;
+ // Move on to the next region.
self.regions.next();
- if let Some(aspect) = self.aspect {
+ if let Some(aspect) = self.stack.aspect {
self.regions.apply_aspect_ratio(aspect);
}
+ self.full = self.regions.current;
+ self.used = Gen::zero();
+ self.ruler = Align::Start;
self.finished.push(output);
}
-
- fn finish(mut self) -> Vec<Frame> {
- self.finish_region();
- self.finished
- }
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-15 18:26:23 +0000