274 lines
8.6 KiB
Rust
274 lines
8.6 KiB
Rust
//! Side-by-side layout of nodes along an axis.
|
|
|
|
use super::prelude::*;
|
|
use super::{AlignNode, SpacingKind};
|
|
|
|
/// Stack children along an axis.
|
|
#[derive(Debug, Hash)]
|
|
pub struct StackNode {
|
|
/// The stacking direction.
|
|
pub dir: Dir,
|
|
/// The spacing between non-spacing children.
|
|
pub spacing: Option<SpacingKind>,
|
|
/// The children to be stacked.
|
|
pub children: Vec<StackChild>,
|
|
}
|
|
|
|
#[class]
|
|
impl StackNode {
|
|
fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Node> {
|
|
Ok(Node::block(Self {
|
|
dir: args.named("dir")?.unwrap_or(Dir::TTB),
|
|
spacing: args.named("spacing")?,
|
|
children: args.all().collect(),
|
|
}))
|
|
}
|
|
}
|
|
|
|
impl Layout for StackNode {
|
|
fn layout(
|
|
&self,
|
|
ctx: &mut LayoutContext,
|
|
regions: &Regions,
|
|
styles: StyleChain,
|
|
) -> Vec<Constrained<Arc<Frame>>> {
|
|
StackLayouter::new(self, regions.clone(), styles).layout(ctx)
|
|
}
|
|
}
|
|
|
|
/// A child of a stack node.
|
|
#[derive(Hash)]
|
|
pub enum StackChild {
|
|
/// Spacing between other nodes.
|
|
Spacing(SpacingKind),
|
|
/// An arbitrary node.
|
|
Node(PackedNode),
|
|
}
|
|
|
|
impl Debug for StackChild {
|
|
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
|
match self {
|
|
Self::Spacing(node) => node.fmt(f),
|
|
Self::Node(node) => node.fmt(f),
|
|
}
|
|
}
|
|
}
|
|
|
|
castable! {
|
|
StackChild,
|
|
Expected: "linear, fractional or template",
|
|
Value::Length(v) => Self::Spacing(SpacingKind::Linear(v.into())),
|
|
Value::Relative(v) => Self::Spacing(SpacingKind::Linear(v.into())),
|
|
Value::Linear(v) => Self::Spacing(SpacingKind::Linear(v)),
|
|
Value::Fractional(v) => Self::Spacing(SpacingKind::Fractional(v)),
|
|
Value::Node(v) => Self::Node(v.into_block()),
|
|
}
|
|
|
|
/// Performs stack layout.
|
|
struct StackLayouter<'a> {
|
|
/// The flow node to layout.
|
|
children: &'a [StackChild],
|
|
/// The stacking direction.
|
|
dir: Dir,
|
|
/// The axis of the stacking direction.
|
|
axis: SpecAxis,
|
|
/// The spacing between non-spacing children.
|
|
spacing: Option<SpacingKind>,
|
|
/// The regions to layout children into.
|
|
regions: Regions,
|
|
/// The inherited styles.
|
|
styles: StyleChain<'a>,
|
|
/// Whether the stack should expand to fill the region.
|
|
expand: Spec<bool>,
|
|
/// The full size of `regions.current` that was available before we started
|
|
/// subtracting.
|
|
full: Size,
|
|
/// The generic size used by the frames for the current region.
|
|
used: Gen<Length>,
|
|
/// 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<Arc<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(Arc<Frame>, Align),
|
|
}
|
|
|
|
impl<'a> StackLayouter<'a> {
|
|
/// Create a new stack layouter.
|
|
fn new(stack: &'a StackNode, mut regions: Regions, styles: StyleChain<'a>) -> Self {
|
|
let dir = stack.dir;
|
|
let axis = dir.axis();
|
|
let expand = regions.expand;
|
|
let full = regions.current;
|
|
|
|
// Disable expansion along the block axis for children.
|
|
regions.expand.set(axis, false);
|
|
|
|
Self {
|
|
children: &stack.children,
|
|
dir,
|
|
axis,
|
|
spacing: stack.spacing,
|
|
regions,
|
|
styles,
|
|
expand,
|
|
full,
|
|
used: Gen::zero(),
|
|
fr: Fractional::zero(),
|
|
items: vec![],
|
|
finished: vec![],
|
|
}
|
|
}
|
|
|
|
/// Layout all children.
|
|
fn layout(mut self, ctx: &mut LayoutContext) -> Vec<Constrained<Arc<Frame>>> {
|
|
// Spacing to insert before the next node.
|
|
let mut deferred = None;
|
|
|
|
for child in self.children {
|
|
match *child {
|
|
StackChild::Spacing(kind) => {
|
|
self.layout_spacing(kind);
|
|
deferred = None;
|
|
}
|
|
StackChild::Node(ref node) => {
|
|
if let Some(kind) = deferred {
|
|
self.layout_spacing(kind);
|
|
}
|
|
|
|
if self.regions.is_full() {
|
|
self.finish_region();
|
|
}
|
|
|
|
self.layout_node(ctx, node);
|
|
deferred = self.spacing;
|
|
}
|
|
}
|
|
}
|
|
|
|
self.finish_region();
|
|
self.finished
|
|
}
|
|
|
|
/// Layout spacing.
|
|
fn layout_spacing(&mut self, spacing: SpacingKind) {
|
|
match spacing {
|
|
SpacingKind::Linear(v) => self.layout_absolute(v),
|
|
SpacingKind::Fractional(v) => {
|
|
self.items.push(StackItem::Fractional(v));
|
|
self.fr += v;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// 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 resolved = amount.resolve(self.regions.base.get(self.axis));
|
|
let limited = resolved.min(*remaining);
|
|
*remaining -= limited;
|
|
self.used.main += limited;
|
|
self.items.push(StackItem::Absolute(resolved));
|
|
}
|
|
|
|
/// Layout a node.
|
|
fn layout_node(&mut self, ctx: &mut LayoutContext, node: &PackedNode) {
|
|
// Align nodes' block-axis alignment is respected by the stack node.
|
|
let align = node
|
|
.downcast::<AlignNode>()
|
|
.and_then(|node| node.aligns.get(self.axis))
|
|
.unwrap_or(self.dir.start().into());
|
|
|
|
let frames = node.layout(ctx, &self.regions, self.styles);
|
|
let len = frames.len();
|
|
for (i, frame) in frames.into_iter().enumerate() {
|
|
// Grow our size, shrink the region and save the frame for later.
|
|
let size = frame.item.size.to_gen(self.axis);
|
|
self.used.main += size.main;
|
|
self.used.cross.set_max(size.cross);
|
|
*self.regions.current.get_mut(self.axis) -= size.main;
|
|
self.items.push(StackItem::Frame(frame.item, align));
|
|
|
|
if i + 1 < len {
|
|
self.finish_region();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Finish the frame for one region.
|
|
fn finish_region(&mut self) {
|
|
// Determine the size of the stack in this region dependening on whether
|
|
// the region expands.
|
|
let used = self.used.to_spec(self.axis);
|
|
let mut size = self.expand.select(self.full, used);
|
|
|
|
// Expand fully if there are fr spacings.
|
|
let full = self.full.get(self.axis);
|
|
let remaining = full - self.used.main;
|
|
if self.fr.get() > 0.0 && full.is_finite() {
|
|
self.used.main = full;
|
|
size.set(self.axis, full);
|
|
}
|
|
|
|
let mut output = Frame::new(size);
|
|
let mut cursor = Length::zero();
|
|
let mut ruler: Align = self.dir.start().into();
|
|
|
|
// Place all frames.
|
|
for item in self.items.drain(..) {
|
|
match item {
|
|
StackItem::Absolute(v) => {
|
|
cursor += v;
|
|
}
|
|
StackItem::Fractional(v) => {
|
|
cursor += v.resolve(self.fr, remaining);
|
|
}
|
|
StackItem::Frame(frame, align) => {
|
|
if self.dir.is_positive() {
|
|
ruler = ruler.max(align);
|
|
} else {
|
|
ruler = ruler.min(align);
|
|
}
|
|
|
|
// Align along the block axis.
|
|
let parent = size.get(self.axis);
|
|
let child = frame.size.get(self.axis);
|
|
let block = ruler.resolve(parent - self.used.main)
|
|
+ if self.dir.is_positive() {
|
|
cursor
|
|
} else {
|
|
self.used.main - child - cursor
|
|
};
|
|
|
|
let pos = Gen::new(Length::zero(), block).to_point(self.axis);
|
|
cursor += child;
|
|
output.push_frame(pos, frame);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generate tight constraints for now.
|
|
let mut cts = Constraints::new(self.expand);
|
|
cts.exact = self.full.map(Some);
|
|
cts.base = self.regions.base.map(Some);
|
|
|
|
// Advance to the next region.
|
|
self.regions.next();
|
|
self.full = self.regions.current;
|
|
self.used = Gen::zero();
|
|
self.fr = Fractional::zero();
|
|
self.finished.push(output.constrain(cts));
|
|
}
|
|
}
|