summaryrefslogtreecommitdiff
path: root/src/layout
diff options
context:
space:
mode:
Diffstat (limited to 'src/layout')
-rw-r--r--src/layout/grid.rs39
-rw-r--r--src/layout/mod.rs9
-rw-r--r--src/layout/par.rs119
-rw-r--r--src/layout/shape.rs3
-rw-r--r--src/layout/stack.rs189
5 files changed, 195 insertions, 164 deletions
diff --git a/src/layout/grid.rs b/src/layout/grid.rs
index 22581696..7220d7c2 100644
--- a/src/layout/grid.rs
+++ b/src/layout/grid.rs
@@ -17,7 +17,7 @@ pub struct GridNode {
pub enum TrackSizing {
/// Fit the cell to its contents.
Auto,
- /// A length stated in absolute values and fractions of the parent's size.
+ /// A length stated in absolute values and/or relative to the parent's size.
Linear(Linear),
/// A length that is the fraction of the remaining free space in the parent.
Fractional(Fractional),
@@ -124,26 +124,23 @@ impl<'a> GridLayouter<'a> {
cols.pop();
rows.pop();
- let full = regions.current.h;
- let rcols = vec![Length::zero(); cols.len()];
-
// We use the regions only for auto row measurement and constraints.
let expand = regions.expand;
regions.expand = Spec::new(true, false);
Self {
- cols,
- rows,
children: &grid.children,
cts: Constraints::new(expand),
- regions,
+ full: regions.current.h,
expand,
- rcols,
+ rcols: vec![Length::zero(); cols.len()],
lrows: vec![],
- full,
used: Size::zero(),
fr: Fractional::zero(),
finished: vec![],
+ cols,
+ rows,
+ regions,
}
}
@@ -313,9 +310,9 @@ impl<'a> GridLayouter<'a> {
TrackSizing::Auto => self.layout_auto_row(ctx, y),
TrackSizing::Linear(v) => self.layout_linear_row(ctx, v, y),
TrackSizing::Fractional(v) => {
- self.fr += v;
self.cts.exact.y = Some(self.full);
self.lrows.push(Row::Fr(v, y));
+ self.fr += v;
}
}
}
@@ -498,22 +495,22 @@ impl<'a> GridLayouter<'a> {
/// Finish rows for one region.
fn finish_region(&mut self, ctx: &mut LayoutContext) {
- // Determine the height of the region's frame.
- let height = if self.fr.is_zero() || self.full.is_infinite() {
- self.used.h
- } else {
- self.full
- };
+ // Determine the size that remains for fractional rows.
+ let remaining = self.full - self.used.h;
+
+ // Determine the size of the grid in this region, expanding fully if
+ // there are fr rows.
+ let mut size = self.used;
+ if !self.fr.is_zero() && self.full.is_finite() {
+ size.h = self.full;
+ }
- self.cts.min.y = Some(height);
+ self.cts.min.y = Some(size.h);
// The frame for the region.
- let mut output = Frame::new(Size::new(self.used.w, height), height);
+ let mut output = Frame::new(size, size.h);
let mut pos = Point::zero();
- // Determine the size that remains for fractional rows.
- let remaining = self.full - self.used.h;
-
// Place finished rows and layout fractional rows.
for row in std::mem::take(&mut self.lrows) {
let frame = match row {
diff --git a/src/layout/mod.rs b/src/layout/mod.rs
index d0313778..651daa21 100644
--- a/src/layout/mod.rs
+++ b/src/layout/mod.rs
@@ -276,3 +276,12 @@ fn hash_node(node: &(impl Hash + 'static)) -> u64 {
node.hash(&mut state);
state.finish()
}
+
+/// Kinds of spacing.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum Spacing {
+ /// A length stated in absolute values and/or relative to 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/par.rs b/src/layout/par.rs
index 4a1e3743..64265b63 100644
--- a/src/layout/par.rs
+++ b/src/layout/par.rs
@@ -19,7 +19,7 @@ pub struct ParNode {
pub dir: Dir,
/// The spacing to insert between each line.
pub leading: Length,
- /// The nodes to be arranged in a paragraph.
+ /// The children to be arranged in a paragraph.
pub children: Vec<ParChild>,
}
@@ -27,11 +27,11 @@ pub struct ParNode {
#[cfg_attr(feature = "layout-cache", derive(Hash))]
pub enum ParChild {
/// Spacing between other nodes.
- Spacing(Linear),
+ Spacing(Spacing),
/// A run of text and how to align it in its line.
Text(EcoString, Align, Rc<TextStyle>),
/// Any child node and how to align it in its line.
- Any(InlineNode, Align),
+ Node(InlineNode, Align),
/// A decoration that applies until a matching `Undecorate`.
Decorate(Decoration),
/// The end of a decoration.
@@ -87,7 +87,7 @@ impl ParNode {
self.children.iter().map(|child| match child {
ParChild::Spacing(_) => " ",
ParChild::Text(ref piece, ..) => piece,
- ParChild::Any(..) => "\u{FFFC}",
+ ParChild::Node(..) => "\u{FFFC}",
ParChild::Decorate(_) | ParChild::Undecorate => "",
})
}
@@ -104,7 +104,7 @@ impl Debug for ParChild {
match self {
Self::Spacing(v) => write!(f, "Spacing({:?})", v),
Self::Text(text, ..) => write!(f, "Text({:?})", text),
- Self::Any(node, ..) => node.fmt(f),
+ Self::Node(node, ..) => node.fmt(f),
Self::Decorate(deco) => write!(f, "Decorate({:?})", deco),
Self::Undecorate => write!(f, "Undecorate"),
}
@@ -120,7 +120,7 @@ struct ParLayouter<'a> {
leading: Length,
/// Bidirectional text embedding levels for the paragraph.
bidi: BidiInfo<'a>,
- /// Layouted children and separated text runs.
+ /// Spacing, separated text runs and layouted nodes.
items: Vec<ParItem<'a>>,
/// The ranges of the items in `bidi.text`.
ranges: Vec<Range>,
@@ -130,8 +130,10 @@ struct ParLayouter<'a> {
/// A prepared item in a paragraph layout.
enum ParItem<'a> {
- /// Spacing between other items.
- Spacing(Length),
+ /// Absolute spacing between other items.
+ Absolute(Length),
+ /// Fractional spacing between other items.
+ Fractional(Fractional),
/// A shaped text run with consistent direction.
Text(ShapedText<'a>, Align),
/// A layouted child node.
@@ -153,27 +155,35 @@ impl<'a> ParLayouter<'a> {
// Layout the children and collect them into items.
for (range, child) in par.ranges().zip(&par.children) {
- match child {
- ParChild::Spacing(amount) => {
- let resolved = amount.resolve(regions.current.w);
- items.push(ParItem::Spacing(resolved));
+ match *child {
+ ParChild::Spacing(Spacing::Linear(v)) => {
+ let resolved = v.resolve(regions.current.w);
+ items.push(ParItem::Absolute(resolved));
ranges.push(range);
}
- ParChild::Text(_, align, style) => {
+ ParChild::Spacing(Spacing::Fractional(v)) => {
+ items.push(ParItem::Fractional(v));
+ ranges.push(range);
+ }
+ ParChild::Text(_, align, ref style) => {
// TODO: Also split by language and script.
- for (subrange, dir) in split_runs(&bidi, range) {
+ let mut cursor = range.start;
+ for (level, group) in bidi.levels[range].group_by_key(|&lvl| lvl) {
+ let start = cursor;
+ cursor += group.len();
+ let subrange = start .. cursor;
let text = &bidi.text[subrange.clone()];
- let shaped = shape(ctx, text, style, dir);
- items.push(ParItem::Text(shaped, *align));
+ let shaped = shape(ctx, text, style, level.dir());
+ items.push(ParItem::Text(shaped, align));
ranges.push(subrange);
}
}
- ParChild::Any(node, align) => {
+ ParChild::Node(ref node, align) => {
let frame = node.layout(ctx, regions.current.w, regions.base);
- items.push(ParItem::Frame(frame, *align));
+ items.push(ParItem::Frame(frame, align));
ranges.push(range);
}
- ParChild::Decorate(deco) => {
+ ParChild::Decorate(ref deco) => {
starts.push((range.start, deco));
}
ParChild::Undecorate => {
@@ -298,41 +308,6 @@ impl<'a> ParLayouter<'a> {
}
}
-/// Split a range of text into runs of consistent direction.
-fn split_runs<'a>(
- bidi: &'a BidiInfo,
- range: Range,
-) -> impl Iterator<Item = (Range, Dir)> + 'a {
- let mut cursor = range.start;
- bidi.levels[range]
- .group_by_key(|&level| level)
- .map(move |(level, group)| {
- let start = cursor;
- cursor += group.len();
- (start .. cursor, level.dir())
- })
-}
-
-impl ParItem<'_> {
- /// The size of the item.
- pub fn size(&self) -> Size {
- match self {
- Self::Spacing(amount) => Size::new(*amount, Length::zero()),
- Self::Text(shaped, ..) => shaped.size,
- Self::Frame(frame, ..) => frame.size,
- }
- }
-
- /// The baseline of the item.
- pub fn baseline(&self) -> Length {
- match self {
- Self::Spacing(_) => Length::zero(),
- Self::Text(shaped, ..) => shaped.baseline,
- Self::Frame(frame, ..) => frame.baseline,
- }
- }
-}
-
/// A lightweight representation of a line that spans a specific range in a
/// paragraph's text. This type enables you to cheaply measure the size of a
/// line in a range before comitting to building the line's frame.
@@ -356,6 +331,8 @@ struct LineLayout<'a> {
size: Size,
/// The baseline of the line.
baseline: Length,
+ /// The sum of fractional ratios in the line.
+ fr: Fractional,
}
impl<'a> LineLayout<'a> {
@@ -422,14 +399,20 @@ impl<'a> LineLayout<'a> {
let mut width = Length::zero();
let mut top = Length::zero();
let mut bottom = Length::zero();
+ let mut fr = Fractional::zero();
// Measure the size of the line.
for item in first.iter().chain(items).chain(&last) {
- let size = item.size();
- let baseline = item.baseline();
- width += size.w;
- top.set_max(baseline);
- bottom.set_max(size.h - baseline);
+ match *item {
+ ParItem::Absolute(v) => width += v,
+ ParItem::Fractional(v) => fr += v,
+ ParItem::Text(ShapedText { size, baseline, .. }, _)
+ | ParItem::Frame(Frame { size, baseline, .. }, _) => {
+ width += size.w;
+ top.set_max(baseline);
+ bottom.set_max(size.h - baseline);
+ }
+ }
}
Self {
@@ -441,13 +424,14 @@ impl<'a> LineLayout<'a> {
ranges,
size: Size::new(width, top + bottom),
baseline: top,
+ fr,
}
}
/// Build the line's frame.
fn build(&self, ctx: &LayoutContext, width: Length) -> Frame {
let size = Size::new(self.size.w.max(width), self.size.h);
- let free = size.w - self.size.w;
+ let remaining = size.w - self.size.w;
let mut output = Frame::new(size, self.baseline);
let mut offset = Length::zero();
@@ -464,7 +448,7 @@ impl<'a> LineLayout<'a> {
// FIXME: Ruler alignment for RTL.
ruler = ruler.max(align);
- let x = ruler.resolve(self.par.dir, offset .. free + offset);
+ let x = ruler.resolve(self.par.dir, offset .. remaining + offset);
let y = self.baseline - frame.baseline;
offset += frame.size.w;
@@ -473,7 +457,13 @@ impl<'a> LineLayout<'a> {
};
match *item {
- ParItem::Spacing(amount) => offset += amount,
+ ParItem::Absolute(v) => offset += v,
+ ParItem::Fractional(v) => {
+ let ratio = v / self.fr;
+ if remaining.is_finite() && ratio.is_finite() {
+ offset += ratio * remaining;
+ }
+ }
ParItem::Text(ref shaped, align) => position(shaped.build(), align),
ParItem::Frame(ref frame, align) => position(frame.clone(), align),
}
@@ -539,6 +529,7 @@ struct LineStack<'a> {
finished: Vec<Constrained<Rc<Frame>>>,
cts: Constraints,
overflowing: bool,
+ fractional: bool,
}
impl<'a> LineStack<'a> {
@@ -553,6 +544,7 @@ impl<'a> LineStack<'a> {
lines: vec![],
finished: vec![],
overflowing: false,
+ fractional: false,
}
}
@@ -566,12 +558,13 @@ impl<'a> LineStack<'a> {
self.size.h += self.leading;
}
+ self.fractional |= !line.fr.is_zero();
self.lines.push(line);
}
/// Finish the frame for one region.
fn finish_region(&mut self, ctx: &LayoutContext) {
- if self.regions.expand.x {
+ if self.regions.expand.x || self.fractional {
self.size.w = self.regions.current.w;
self.cts.exact.x = Some(self.regions.current.w);
}
diff --git a/src/layout/shape.rs b/src/layout/shape.rs
index 13d5418f..2e66a0dd 100644
--- a/src/layout/shape.rs
+++ b/src/layout/shape.rs
@@ -55,8 +55,7 @@ impl InlineLevel for ShapeNode {
// The "pod" is the region into which the child will be layouted.
let mut pod = {
- let size =
- Size::new(width.unwrap_or(space), height.unwrap_or(Length::inf()));
+ let size = Size::new(width.unwrap_or(space), height.unwrap_or(base.h));
let base = Size::new(
if width.is_some() { size.w } else { base.w },
diff --git a/src/layout/stack.rs b/src/layout/stack.rs
index bbaf022b..dbd9ddb0 100644
--- a/src/layout/stack.rs
+++ b/src/layout/stack.rs
@@ -8,7 +8,7 @@ use super::*;
pub struct StackNode {
/// The stacking direction.
pub dir: Dir,
- /// The nodes to be stacked.
+ /// The children to be stacked.
pub children: Vec<StackChild>,
}
@@ -16,9 +16,9 @@ pub struct StackNode {
#[cfg_attr(feature = "layout-cache", derive(Hash))]
pub enum StackChild {
/// Spacing between other nodes.
- Spacing(Linear),
+ Spacing(Spacing),
/// Any block node and how to align it in the stack.
- Any(BlockNode, Align),
+ Node(BlockNode, Align),
}
impl BlockLevel for StackNode {
@@ -41,7 +41,7 @@ impl Debug for StackChild {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
match self {
Self::Spacing(v) => write!(f, "Spacing({:?})", v),
- Self::Any(node, _) => node.fmt(f),
+ Self::Node(node, _) => node.fmt(f),
}
}
}
@@ -61,34 +61,41 @@ struct StackLayouter<'a> {
full: Size,
/// The generic size used by the frames for the current region.
used: Gen<Length>,
- /// The alignment ruler for the current region.
- ruler: Align,
- /// Offset, alignment and frame for all children that fit into the current
- /// region. The exact positions are not known yet.
- frames: Vec<(Length, Align, Rc<Frame>)>,
+ /// The sum of fractional ratios in the current region.
+ fr: Fractional,
+ /// Spacing and layouted nodes.
+ items: Vec<StackItem>,
/// Finished frames for previous regions.
finished: Vec<Constrained<Rc<Frame>>>,
}
+/// A prepared item in a stack layout.
+enum StackItem {
+ /// Absolute spacing between other items.
+ Absolute(Length),
+ /// Fractional spacing between other items.
+ Fractional(Fractional),
+ /// A layouted child node.
+ Frame(Rc<Frame>, Align),
+}
+
impl<'a> StackLayouter<'a> {
/// Create a new stack layouter.
fn new(stack: &'a StackNode, mut regions: Regions) -> Self {
+ // Disable expansion along the block axis for children.
let axis = stack.dir.axis();
- let full = regions.current;
let expand = regions.expand;
-
- // Disable expansion along the block axis for children.
regions.expand.set(axis, false);
Self {
stack,
axis,
expand,
+ full: regions.current,
regions,
- full,
used: Gen::zero(),
- ruler: Align::Start,
- frames: vec![],
+ fr: Fractional::zero(),
+ items: vec![],
finished: vec![],
}
}
@@ -97,16 +104,15 @@ impl<'a> StackLayouter<'a> {
fn layout(mut self, ctx: &mut LayoutContext) -> Vec<Constrained<Rc<Frame>>> {
for child in &self.stack.children {
match *child {
- StackChild::Spacing(amount) => self.space(amount),
- StackChild::Any(ref node, align) => {
- let frames = node.layout(ctx, &self.regions);
- let len = frames.len();
- for (i, frame) in frames.into_iter().enumerate() {
- self.push_frame(frame.item, align);
- if i + 1 < len {
- self.finish_region();
- }
- }
+ StackChild::Spacing(Spacing::Linear(v)) => {
+ self.layout_absolute(v);
+ }
+ StackChild::Spacing(Spacing::Fractional(v)) => {
+ self.items.push(StackItem::Fractional(v));
+ self.fr += v;
+ }
+ StackChild::Node(ref node, align) => {
+ self.layout_node(ctx, node, align);
}
}
}
@@ -115,75 +121,102 @@ impl<'a> StackLayouter<'a> {
self.finished
}
- /// Add block-axis spacing into the current region.
- fn space(&mut self, amount: Linear) {
- // Resolve the linear.
- let full = self.full.get(self.axis);
- let resolved = amount.resolve(full);
-
- // Cap the spacing to the remaining available space. This action does
- // not directly affect the constraints because of the cap.
+ /// Layout absolute spacing.
+ fn layout_absolute(&mut self, amount: Linear) {
+ // Resolve the linear, limiting it to the remaining available space.
let remaining = self.regions.current.get_mut(self.axis);
- let capped = resolved.min(*remaining);
-
- // Grow our size and shrink the available space in the region.
- self.used.block += capped;
- *remaining -= capped;
+ let resolved = amount.resolve(self.full.get(self.axis));
+ let limited = resolved.min(*remaining);
+ *remaining -= limited;
+ self.used.block += limited;
+ self.items.push(StackItem::Absolute(resolved));
}
- /// Push a frame into the current region.
- fn push_frame(&mut self, frame: Rc<Frame>, align: Align) {
- // Grow our size.
- let offset = self.used.block;
- let size = frame.size.to_gen(self.axis);
- self.used.block += size.block;
- self.used.inline.set_max(size.inline);
- self.ruler = self.ruler.max(align);
-
- // Remember the frame and shrink available space in the region for the
- // following children.
- self.frames.push((offset, self.ruler, frame));
- *self.regions.current.get_mut(self.axis) -= size.block;
+ /// Layout a block node.
+ fn layout_node(&mut self, ctx: &mut LayoutContext, node: &BlockNode, align: Align) {
+ let frames = node.layout(ctx, &self.regions);
+ let len = frames.len();
+ for (i, frame) in frames.into_iter().enumerate() {
+ // Grow our size.
+ let size = frame.item.size.to_gen(self.axis);
+ self.used.block += size.block;
+ self.used.inline.set_max(size.inline);
+
+ // Remember the frame and shrink available space in the region for the
+ // following children.
+ self.items.push(StackItem::Frame(frame.item, align));
+ *self.regions.current.get_mut(self.axis) -= size.block;
+
+ if i + 1 < len {
+ self.finish_region();
+ }
+ }
}
/// Finish the frame for one region.
fn finish_region(&mut self) {
- // Determine the stack's size dependening on whether the region expands.
+ // Determine the size that remains for fractional spacing.
+ let remaining = self.full.get(self.axis) - self.used.block;
+
+ // Determine the size of the stack in this region dependening on whether
+ // the region expands.
let used = self.used.to_size(self.axis);
- let size = Size::new(
+ let mut size = Size::new(
if self.expand.x { self.full.w } else { used.w },
if self.expand.y { self.full.h } else { used.h },
);
+ // Expand fully if there are fr spacings.
+ let full = self.full.get(self.axis);
+ if !self.fr.is_zero() && full.is_finite() {
+ size.set(self.axis, full);
+ }
+
let mut output = Frame::new(size, size.h);
+ let mut before = Length::zero();
+ let mut ruler = Align::Start;
let mut first = true;
// Place all frames.
- for (offset, align, frame) in self.frames.drain(..) {
- let stack_size = size.to_gen(self.axis);
- let child_size = frame.size.to_gen(self.axis);
-
- // Align along the block axis.
- let block = align.resolve(
- self.stack.dir,
- if self.stack.dir.is_positive() {
- offset .. stack_size.block - self.used.block + offset
- } else {
- let offset_with_self = offset + child_size.block;
- self.used.block - offset_with_self
- .. stack_size.block - offset_with_self
- },
- );
-
- let pos = Gen::new(Length::zero(), block).to_point(self.axis);
-
- // The baseline of the stack is that of the first frame.
- if first {
- output.baseline = pos.y + frame.baseline;
- first = false;
- }
+ for item in self.items.drain(..) {
+ match item {
+ StackItem::Absolute(v) => before += v,
+ StackItem::Fractional(v) => {
+ let ratio = v / self.fr;
+ if remaining.is_finite() && ratio.is_finite() {
+ before += ratio * remaining;
+ }
+ }
+ StackItem::Frame(frame, align) => {
+ ruler = ruler.max(align);
+
+ let parent = size.to_gen(self.axis);
+ let child = frame.size.to_gen(self.axis);
+
+ // Align along the block axis.
+ let block = ruler.resolve(
+ self.stack.dir,
+ if self.stack.dir.is_positive() {
+ let after = self.used.block - before;
+ before .. parent.block - after
+ } else {
+ let before_with_self = before + child.block;
+ let after = self.used.block - before_with_self;
+ after .. parent.block - before_with_self
+ },
+ );
+
+ let pos = Gen::new(Length::zero(), block).to_point(self.axis);
+ if first {
+ // The baseline of the stack is that of the first frame.
+ output.baseline = pos.y + frame.baseline;
+ first = false;
+ }
- output.push_frame(pos, frame);
+ output.push_frame(pos, frame);
+ before += child.block;
+ }
+ }
}
// Generate tight constraints for now.
@@ -194,7 +227,7 @@ impl<'a> StackLayouter<'a> {
self.regions.next();
self.full = self.regions.current;
self.used = Gen::zero();
- self.ruler = Align::Start;
+ self.fr = Fractional::zero();
self.finished.push(output.constrain(cts));
}
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-16 19:12:22 +0000