use crate::glue::Glue;
use crate::node::{DiscNode, GlueNode, GlueSource, Node, Scaled};
use crate::pack::{append_to_vlist, hpack, Baselines, Report, Spec, Tolerances};
use crate::page::{interline_penalty, ParPenalties};
#[derive(Clone, Copy, Debug, Default)]
pub struct Skips {
pub left_skip: Glue,
pub right_skip: Glue,
}
#[derive(Clone, Debug)]
pub struct LineShape {
last_special_line: usize,
first: (Scaled, Scaled),
second: (Scaled, Scaled),
par_shape: Vec<(Scaled, Scaled)>,
}
impl LineShape {
pub fn fixed(hsize: Scaled) -> LineShape {
LineShape {
last_special_line: 0,
first: (0, hsize),
second: (0, hsize),
par_shape: Vec::new(),
}
}
pub fn hanging(hsize: Scaled, hang_indent: Scaled, hang_after: i64) -> LineShape {
let narrow = hsize - hang_indent.abs();
let indent = hang_indent.max(0);
match hang_after < 0 {
true => LineShape {
last_special_line: hang_after.unsigned_abs() as usize,
first: (indent, narrow),
second: (0, hsize),
par_shape: Vec::new(),
},
false => LineShape {
last_special_line: hang_after as usize,
first: (0, hsize),
second: (indent, narrow),
par_shape: Vec::new(),
},
}
}
pub fn par_shape(hsize: Scaled, shape: Vec<(Scaled, Scaled)>) -> LineShape {
let Some(&last) = shape.last() else {
return LineShape::fixed(hsize);
};
LineShape {
last_special_line: shape.len() - 1,
first: (0, hsize),
second: last,
par_shape: shape,
}
}
pub fn line(&self, cur_line: usize) -> (Scaled, Scaled) {
if cur_line > self.last_special_line {
return self.second;
}
match self.par_shape.is_empty() {
true => self.first,
false => self.par_shape[cur_line - 1],
}
}
}
#[derive(Clone, Debug)]
pub struct ParParams {
pub shape: LineShape,
pub skips: Skips,
pub penalties: ParPenalties,
pub baselines: Baselines,
pub tolerances: Tolerances,
}
impl ParParams {
pub fn plain(hsize: Scaled) -> ParParams {
ParParams {
shape: LineShape::fixed(hsize),
skips: Skips::default(),
penalties: ParPenalties::latex(),
baselines: Baselines::plain(),
tolerances: Tolerances::plain(),
}
}
}
#[derive(Clone, Debug)]
pub struct Paragraph {
pub list: Vec<Node>,
pub reports: Vec<Option<Report>>,
pub badness: Vec<i64>,
}
pub fn post_line_break(
list: Vec<Node>,
breaks: &[usize],
params: &ParParams,
prev_depth: &mut Scaled,
) -> Paragraph {
let mut nodes: Vec<Option<Node>> = list.into_iter().map(Some).collect();
let total = breaks.len();
let mut out = Paragraph {
list: Vec::new(),
reports: Vec::with_capacity(total),
badness: Vec::with_capacity(total),
};
let mut pending: Vec<Node> = Vec::new();
let mut pos = 0usize;
for (i, &brk) in breaks.iter().enumerate() {
let cur_line = i + 1;
let brk = brk.min(nodes.len());
let mut line: Vec<Node> = std::mem::take(&mut pending);
for slot in nodes.iter_mut().take(brk).skip(pos) {
if let Some(node) = slot.take() {
line.push(node);
}
}
let right_skip = Node::Glue(GlueNode::param(
params.skips.right_skip,
GlueSource::RightSkip,
));
let mut disc_break = false;
let mut post_disc_break = false;
let mut next;
match nodes.get_mut(brk).and_then(Option::take) {
Some(Node::Glue(_)) => {
line.push(right_skip);
next = brk + 1;
}
Some(Node::Disc(d)) => {
let end = (brk + 1 + d.replace_count).min(nodes.len());
for slot in nodes.iter_mut().take(end).skip(brk + 1) {
slot.take();
}
next = end;
line.push(Node::Disc(DiscNode::default()));
line.extend(d.pre_break);
post_disc_break = !d.post_break.is_empty();
pending = d.post_break;
disc_break = true;
line.push(right_skip);
}
Some(Node::Math(_)) => {
line.push(Node::Math(0));
line.push(right_skip);
next = brk + 1;
}
Some(Node::Kern { explicit, .. }) => {
line.push(Node::Kern { width: 0, explicit });
line.push(right_skip);
next = brk + 1;
}
Some(other) => {
line.push(other);
line.push(right_skip);
next = brk + 1;
}
None => {
line.push(right_skip);
next = nodes.len();
}
}
if params.skips.left_skip != Glue::default() {
line.insert(
0,
Node::Glue(GlueNode::param(
params.skips.left_skip,
GlueSource::LeftSkip,
)),
);
}
let (indent, width) = params.shape.line(cur_line);
let mut adjust: Vec<Node> = Vec::new();
let packed = hpack(
line,
Spec::Exactly(width),
params.tolerances,
Some(&mut adjust),
);
let mut just_box = packed.node;
just_box.shift_amount = indent;
out.reports.push(packed.report);
out.badness.push(packed.badness);
append_to_vlist(&mut out.list, just_box, prev_depth, params.baselines);
out.list.append(&mut adjust);
if let Some(pen) = interline_penalty(i, total, disc_break, params.penalties) {
out.list.push(Node::Penalty(pen));
}
if i + 1 < total && !post_disc_break {
let stop = breaks[i + 1].min(nodes.len());
while next < stop {
let discardable = match nodes[next].as_ref() {
None => true,
Some(node) if node.is_char() => false,
Some(node) if node.non_discardable() => false,
Some(Node::Kern { explicit, .. }) => *explicit,
Some(_) => true,
};
if !discardable {
break;
}
nodes[next].take();
next += 1;
}
}
pos = next;
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use crate::glue::Glue;
use crate::node::BoxNode;
use crate::pack::glue_widths;
fn pt(n: i64) -> Scaled {
n * crate::dimen::UNITY
}
fn word(width: Scaled) -> Node {
Node::Box(BoxNode {
width,
height: pt(7),
depth: pt(2),
..BoxNode::null()
})
}
fn space() -> Node {
Node::Glue(GlueNode::new(Glue {
natural: pt(4),
stretch: pt(2),
shrink: pt(1),
..Glue::default()
}))
}
fn paragraph() -> Vec<Node> {
let mut list = Vec::new();
for i in 0..4 {
if i > 0 {
list.push(space());
}
list.push(word(pt(20)));
}
list
}
fn boxes(list: &[Node]) -> Vec<&BoxNode> {
list.iter()
.filter_map(|n| match n {
Node::Box(b) => Some(b),
_ => None,
})
.collect()
}
#[test]
fn every_line_is_packed_to_its_own_measure() {
let mut prev_depth = crate::node::IGNORE_DEPTH;
let par = post_line_break(
paragraph(),
&[3, usize::MAX],
&ParParams::plain(pt(60)),
&mut prev_depth,
);
let lines = boxes(&par.list);
assert_eq!(lines.len(), 2);
assert_eq!(lines[0].width, pt(60));
assert_eq!(lines[1].width, pt(60));
assert_eq!(prev_depth, pt(2));
}
#[test]
fn the_glue_at_a_break_becomes_rightskip() {
let mut prev_depth = crate::node::IGNORE_DEPTH;
let ragged = ParParams {
skips: Skips {
left_skip: Glue::default(),
right_skip: Glue {
natural: 0,
stretch: crate::dimen::UNITY,
stretch_order: 1,
..Glue::default()
},
},
..ParParams::plain(pt(60))
};
let par = post_line_break(paragraph(), &[3, usize::MAX], &ragged, &mut prev_depth);
let lines = boxes(&par.list);
let widths = glue_widths(lines[0]);
assert_eq!(widths.len(), 2);
assert_eq!(widths[0], pt(4), "the space did not stretch");
assert_eq!(widths[1], pt(16), "the rightskip took all the slack");
assert_eq!(lines[0].glue_order, 1);
}
#[test]
fn a_line_broken_at_a_penalty_keeps_the_penalty_and_gains_a_rightskip() {
let mut list = vec![word(pt(20)), Node::Penalty(-500), word(pt(20))];
list.insert(2, space());
let mut prev_depth = crate::node::IGNORE_DEPTH;
let par = post_line_break(
list,
&[1, usize::MAX],
&ParParams::plain(pt(60)),
&mut prev_depth,
);
let lines = boxes(&par.list);
let first: Vec<u8> = lines[0].list.iter().map(Node::type_code).collect();
assert_eq!(first, vec![0, 12, 10]);
assert!(matches!(lines[0].list[1], Node::Penalty(-500)));
}
#[test]
fn the_glue_at_the_break_does_not_start_the_next_line() {
let mut prev_depth = crate::node::IGNORE_DEPTH;
let par = post_line_break(
paragraph(),
&[3, usize::MAX],
&ParParams::plain(pt(60)),
&mut prev_depth,
);
let lines = boxes(&par.list);
let second: Vec<u8> = lines[1].list.iter().map(Node::type_code).collect();
assert_eq!(second, vec![0, 10, 0, 10]);
}
#[test]
fn a_discretionary_break_transplants_both_of_its_lists() {
let hyphen = word(pt(3));
let replaced = word(pt(9));
let list = vec![
word(pt(20)),
Node::Disc(DiscNode {
pre_break: vec![hyphen],
post_break: vec![word(pt(5))],
replace_count: 1,
}),
replaced,
word(pt(20)),
];
let mut prev_depth = crate::node::IGNORE_DEPTH;
let par = post_line_break(
list,
&[1, usize::MAX],
&ParParams::plain(pt(60)),
&mut prev_depth,
);
let lines = boxes(&par.list);
let first: Vec<Scaled> = boxes(&lines[0].list).iter().map(|b| b.width).collect();
assert_eq!(first, vec![pt(20), pt(3)]);
let second: Vec<Scaled> = boxes(&lines[1].list).iter().map(|b| b.width).collect();
assert_eq!(second, vec![pt(5), pt(20)]);
let penalties: Vec<i64> = par
.list
.iter()
.filter_map(|n| match n {
Node::Penalty(p) => Some(*p),
_ => None,
})
.collect();
assert_eq!(
penalties,
vec![150 + 150 + 100],
"a two-line paragraph is charged both club and widow, plus brokenpenalty"
);
}
#[test]
fn vadjust_material_leaves_the_line_and_follows_it() {
let marker = Node::Box(BoxNode {
width: pt(99),
..BoxNode::null()
});
let list = vec![
word(pt(20)),
Node::Adjust(vec![marker]),
space(),
word(pt(20)),
];
let mut prev_depth = crate::node::IGNORE_DEPTH;
let par = post_line_break(
list,
&[usize::MAX],
&ParParams::plain(pt(60)),
&mut prev_depth,
);
let lines = boxes(&par.list);
assert_eq!(lines.len(), 2);
assert_eq!(lines[0].width, pt(60));
assert_eq!(lines[1].width, pt(99));
assert!(boxes(&lines[0].list).iter().all(|b| b.width == pt(20)));
}
#[test]
fn the_lines_come_out_a_baselineskip_apart() {
let mut prev_depth = crate::node::IGNORE_DEPTH;
let par = post_line_break(
paragraph(),
&[3, usize::MAX],
&ParParams::plain(pt(60)),
&mut prev_depth,
);
let interline: Vec<Scaled> = par
.list
.iter()
.filter_map(|n| match n {
Node::Glue(g) if g.source == GlueSource::BaselineSkip => Some(g.spec.natural),
_ => None,
})
.collect();
assert_eq!(interline, vec![pt(3)]);
}
#[test]
fn hanging_indentation_moves_the_lines_hangafter_names() {
let shape = LineShape::hanging(pt(100), pt(20), -2);
assert_eq!(shape.line(1), (pt(20), pt(80)));
assert_eq!(shape.line(2), (pt(20), pt(80)));
assert_eq!(shape.line(3), (0, pt(100)));
let after = LineShape::hanging(pt(100), pt(20), 1);
assert_eq!(after.line(1), (0, pt(100)));
assert_eq!(after.line(2), (pt(20), pt(80)));
let right = LineShape::hanging(pt(100), pt(-20), 1);
assert_eq!(right.line(2), (0, pt(80)));
}
#[test]
fn parshape_names_each_line_and_the_last_pair_governs_the_rest() {
let shape = LineShape::par_shape(pt(100), vec![(pt(10), pt(90)), (pt(5), pt(95))]);
assert_eq!(shape.line(1), (pt(10), pt(90)));
assert_eq!(shape.line(2), (pt(5), pt(95)));
assert_eq!(shape.line(3), (pt(5), pt(95)));
}
#[test]
fn the_indent_is_a_shift_and_not_part_of_the_line() {
let mut prev_depth = crate::node::IGNORE_DEPTH;
let params = ParParams {
shape: LineShape::hanging(pt(60), pt(12), -1),
..ParParams::plain(pt(60))
};
let par = post_line_break(paragraph(), &[3, usize::MAX], ¶ms, &mut prev_depth);
let lines = boxes(&par.list);
assert_eq!(lines[0].shift_amount, pt(12));
assert_eq!(lines[0].width, pt(48));
assert_eq!(lines[1].shift_amount, 0);
assert_eq!(lines[1].width, pt(60));
}
}