283 lines
8.8 KiB
Rust
283 lines
8.8 KiB
Rust
//! A flow of paragraphs and other block-level nodes.
|
|
|
|
use super::prelude::*;
|
|
use super::{AlignNode, ParNode, PlaceNode, SpacingKind, TextNode};
|
|
|
|
/// Arrange spacing, paragraphs and other block-level nodes into a flow.
|
|
///
|
|
/// This node is reponsible for layouting both the top-level content flow and
|
|
/// the contents of boxes.
|
|
#[derive(Hash)]
|
|
pub struct FlowNode(pub StyleVec<FlowChild>);
|
|
|
|
/// A child of a flow node.
|
|
#[derive(Hash)]
|
|
pub enum FlowChild {
|
|
/// A paragraph / block break.
|
|
Parbreak,
|
|
/// A column / region break.
|
|
Colbreak,
|
|
/// Vertical spacing between other children.
|
|
Spacing(SpacingKind),
|
|
/// An arbitrary block-level node.
|
|
Node(PackedNode),
|
|
}
|
|
|
|
impl Layout for FlowNode {
|
|
fn layout(
|
|
&self,
|
|
ctx: &mut LayoutContext,
|
|
regions: &Regions,
|
|
styles: StyleChain,
|
|
) -> Vec<Constrained<Arc<Frame>>> {
|
|
let mut layouter = FlowLayouter::new(regions);
|
|
|
|
for (child, map) in self.0.iter() {
|
|
let styles = map.chain(&styles);
|
|
match child {
|
|
FlowChild::Parbreak => {
|
|
let em = styles.get(TextNode::SIZE).abs;
|
|
let amount = styles.get(ParNode::SPACING).resolve(em);
|
|
layouter.layout_spacing(SpacingKind::Linear(amount.into()));
|
|
}
|
|
FlowChild::Colbreak => {
|
|
layouter.finish_region();
|
|
}
|
|
FlowChild::Spacing(kind) => {
|
|
layouter.layout_spacing(*kind);
|
|
}
|
|
FlowChild::Node(ref node) => {
|
|
layouter.layout_node(ctx, node, styles);
|
|
}
|
|
}
|
|
}
|
|
|
|
layouter.finish()
|
|
}
|
|
}
|
|
|
|
impl Merge for FlowChild {
|
|
fn merge(&mut self, _: &Self) -> bool {
|
|
false
|
|
}
|
|
}
|
|
|
|
impl Debug for FlowNode {
|
|
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
|
f.write_str("Flow ")?;
|
|
self.0.fmt(f)
|
|
}
|
|
}
|
|
|
|
impl Debug for FlowChild {
|
|
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
|
match self {
|
|
Self::Parbreak => f.pad("Parbreak"),
|
|
Self::Colbreak => f.pad("Colbreak"),
|
|
Self::Spacing(kind) => write!(f, "{:?}", kind),
|
|
Self::Node(node) => node.fmt(f),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Performs flow layout.
|
|
pub struct FlowLayouter {
|
|
/// The regions to layout children into.
|
|
regions: Regions,
|
|
/// Whether the flow 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 size used by the frames for the current region.
|
|
used: Size,
|
|
/// The sum of fractional ratios in the current region.
|
|
fr: Fractional,
|
|
/// Whether to add leading before the next node.
|
|
leading: bool,
|
|
/// Spacing and layouted nodes.
|
|
items: Vec<FlowItem>,
|
|
/// Finished frames for previous regions.
|
|
finished: Vec<Constrained<Arc<Frame>>>,
|
|
}
|
|
|
|
/// A prepared item in a flow layout.
|
|
enum FlowItem {
|
|
/// Absolute spacing between other items.
|
|
Absolute(Length),
|
|
/// Fractional spacing between other items.
|
|
Fractional(Fractional),
|
|
/// A frame for a layouted child node and how to align it.
|
|
Frame(Arc<Frame>, Spec<Align>),
|
|
/// An absolutely placed frame.
|
|
Placed(Arc<Frame>),
|
|
}
|
|
|
|
impl FlowLayouter {
|
|
/// Create a new flow layouter.
|
|
pub fn new(regions: &Regions) -> Self {
|
|
let expand = regions.expand;
|
|
let full = regions.current;
|
|
|
|
// Disable vertical expansion for children.
|
|
let mut regions = regions.clone();
|
|
regions.expand.y = false;
|
|
|
|
Self {
|
|
regions,
|
|
expand,
|
|
full,
|
|
used: Size::zero(),
|
|
fr: Fractional::zero(),
|
|
leading: false,
|
|
items: vec![],
|
|
finished: vec![],
|
|
}
|
|
}
|
|
|
|
/// Layout spacing.
|
|
pub fn layout_spacing(&mut self, spacing: SpacingKind) {
|
|
match spacing {
|
|
SpacingKind::Linear(v) => {
|
|
// Resolve the linear and limit it to the remaining space.
|
|
let resolved = v.resolve(self.full.y);
|
|
let limited = resolved.min(self.regions.current.y);
|
|
self.regions.current.y -= limited;
|
|
self.used.y += limited;
|
|
self.items.push(FlowItem::Absolute(resolved));
|
|
}
|
|
SpacingKind::Fractional(v) => {
|
|
self.items.push(FlowItem::Fractional(v));
|
|
self.fr += v;
|
|
self.leading = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Layout a node.
|
|
pub fn layout_node(
|
|
&mut self,
|
|
ctx: &mut LayoutContext,
|
|
node: &PackedNode,
|
|
styles: StyleChain,
|
|
) {
|
|
// Don't even try layouting into a full region.
|
|
if self.regions.is_full() {
|
|
self.finish_region();
|
|
}
|
|
|
|
// Placed nodes that are out of flow produce placed items which aren't
|
|
// aligned later.
|
|
let mut is_placed = false;
|
|
if let Some(placed) = node.downcast::<PlaceNode>() {
|
|
is_placed = true;
|
|
if placed.out_of_flow() {
|
|
let frame = node.layout(ctx, &self.regions, styles).remove(0);
|
|
self.items.push(FlowItem::Placed(frame.item));
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Add leading.
|
|
if self.leading {
|
|
let em = styles.get(TextNode::SIZE).abs;
|
|
let amount = styles.get(ParNode::LEADING).resolve(em);
|
|
self.layout_spacing(SpacingKind::Linear(amount.into()));
|
|
}
|
|
|
|
// How to align the node.
|
|
let aligns = Spec::new(
|
|
// For non-expanding paragraphs it is crucial that we align the
|
|
// whole paragraph as it is itself aligned.
|
|
styles.get(ParNode::ALIGN),
|
|
// Vertical align node alignment is respected by the flow node.
|
|
node.downcast::<AlignNode>()
|
|
.and_then(|aligned| aligned.aligns.y)
|
|
.unwrap_or(Align::Top),
|
|
);
|
|
|
|
let frames = node.layout(ctx, &self.regions, 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;
|
|
self.used.y += size.y;
|
|
self.used.x.set_max(size.x);
|
|
self.regions.current.y -= size.y;
|
|
self.items.push(FlowItem::Frame(frame.item, aligns));
|
|
|
|
if i + 1 < len {
|
|
self.finish_region();
|
|
}
|
|
}
|
|
|
|
self.leading = !is_placed;
|
|
}
|
|
|
|
/// Finish the frame for one region.
|
|
pub fn finish_region(&mut self) {
|
|
// Determine the size of the flow in this region dependening on whether
|
|
// the region expands.
|
|
let mut size = self.expand.select(self.full, self.used);
|
|
|
|
// Account for fractional spacing in the size calculation.
|
|
let remaining = self.full.y - self.used.y;
|
|
if self.fr.get() > 0.0 && self.full.y.is_finite() {
|
|
self.used.y = self.full.y;
|
|
size.y = self.full.y;
|
|
}
|
|
|
|
let mut output = Frame::new(size);
|
|
let mut offset = Length::zero();
|
|
let mut ruler = Align::Top;
|
|
|
|
// Place all frames.
|
|
for item in self.items.drain(..) {
|
|
match item {
|
|
FlowItem::Absolute(v) => {
|
|
offset += v;
|
|
}
|
|
FlowItem::Fractional(v) => {
|
|
offset += v.resolve(self.fr, remaining);
|
|
}
|
|
FlowItem::Frame(frame, aligns) => {
|
|
ruler = ruler.max(aligns.y);
|
|
let x = aligns.x.resolve(size.x - frame.size.x);
|
|
let y = offset + ruler.resolve(size.y - self.used.y);
|
|
let pos = Point::new(x, y);
|
|
offset += frame.size.y;
|
|
output.push_frame(pos, frame);
|
|
}
|
|
FlowItem::Placed(frame) => {
|
|
output.push_frame(Point::zero(), 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 = Size::zero();
|
|
self.fr = Fractional::zero();
|
|
self.leading = false;
|
|
self.finished.push(output.constrain(cts));
|
|
}
|
|
|
|
/// Finish layouting and return the resulting frames.
|
|
pub fn finish(mut self) -> Vec<Constrained<Arc<Frame>>> {
|
|
if self.expand.y {
|
|
while self.regions.backlog.len() > 0 {
|
|
self.finish_region();
|
|
}
|
|
}
|
|
|
|
self.finish_region();
|
|
self.finished
|
|
}
|
|
}
|