use crate::dimen::UNITY;
use crate::glue::Glue;
use crate::node::{BoxNode, GlueNode, LeaderKind, Node, RuleNode, Scaled, IGNORE_DEPTH, NULL_FLAG};
use crate::pack::{hpack, vpack, vpackage, vtop, Baselines, Packed, Spec, Tolerances};
use std::collections::BTreeMap;
pub const DEFAULT_RULE: Scaled = 26214;
pub trait Registers {
fn box_register(&self, n: u8) -> Option<&BoxNode>;
fn take_box(&mut self, n: u8) -> Option<BoxNode>;
fn set_box(&mut self, n: u8, value: Option<BoxNode>);
fn dimen(&self, n: u8) -> Scaled;
fn set_dimen(&mut self, n: u8, value: Scaled);
fn skip(&self, n: u8) -> Glue;
fn set_skip(&mut self, n: u8, value: Glue);
}
#[derive(Clone, Debug, Default)]
pub struct Boxes {
boxes: BTreeMap<u8, BoxNode>,
dimens: BTreeMap<u8, Scaled>,
skips: BTreeMap<u8, Glue>,
}
impl Registers for Boxes {
fn box_register(&self, n: u8) -> Option<&BoxNode> {
self.boxes.get(&n)
}
fn take_box(&mut self, n: u8) -> Option<BoxNode> {
self.boxes.remove(&n)
}
fn set_box(&mut self, n: u8, value: Option<BoxNode>) {
match value {
Some(b) => self.boxes.insert(n, b),
None => self.boxes.remove(&n),
};
}
fn dimen(&self, n: u8) -> Scaled {
self.dimens.get(&n).copied().unwrap_or(0)
}
fn set_dimen(&mut self, n: u8, value: Scaled) {
self.dimens.insert(n, value);
}
fn skip(&self, n: u8) -> Glue {
self.skips.get(&n).copied().unwrap_or_default()
}
fn set_skip(&mut self, n: u8, value: Glue) {
self.skips.insert(n, value);
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Kind {
H,
V,
Top,
}
pub fn package(
kind: Kind,
list: Vec<Node>,
spec: Spec,
max_depth: Scaled,
tol: Tolerances,
) -> Packed {
match kind {
Kind::H => hpack(list, spec, tol, None),
Kind::V => vpackage(list, spec, max_depth, tol),
Kind::Top => vtop(vpackage(list, spec, max_depth, tol)),
}
}
pub fn raise(mut b: BoxNode, by: Scaled) -> BoxNode {
b.shift_amount = -by;
b
}
pub fn lower(mut b: BoxNode, by: Scaled) -> BoxNode {
b.shift_amount = by;
b
}
pub fn move_left(mut b: BoxNode, by: Scaled) -> BoxNode {
b.shift_amount = -by;
b
}
pub fn move_right(mut b: BoxNode, by: Scaled) -> BoxNode {
b.shift_amount = by;
b
}
pub fn hrule() -> RuleNode {
RuleNode {
width: NULL_FLAG,
height: DEFAULT_RULE,
depth: 0,
}
}
pub fn vrule() -> RuleNode {
RuleNode {
width: DEFAULT_RULE,
height: NULL_FLAG,
depth: NULL_FLAG,
}
}
pub mod fill {
use super::{Glue, UNITY};
pub fn fil() -> Glue {
Glue {
stretch: UNITY,
stretch_order: 1,
..Glue::default()
}
}
pub fn fill() -> Glue {
Glue {
stretch: UNITY,
stretch_order: 2,
..Glue::default()
}
}
pub fn filll() -> Glue {
Glue {
stretch: UNITY,
stretch_order: 3,
..Glue::default()
}
}
pub fn ss() -> Glue {
Glue {
stretch: UNITY,
stretch_order: 1,
shrink: UNITY,
shrink_order: 1,
..Glue::default()
}
}
pub fn fil_neg() -> Glue {
Glue {
stretch: -UNITY,
stretch_order: 1,
..Glue::default()
}
}
}
#[derive(Clone, PartialEq, Eq, Debug)]
pub enum BoxError {
IncompatibleList,
}
impl std::fmt::Display for BoxError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
BoxError::IncompatibleList => write!(f, "Incompatible list can't be unboxed"),
}
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Mode {
Horizontal,
Vertical,
}
pub struct ListBuilder {
pub mode: Mode,
pub list: Vec<Node>,
pub prev_depth: Scaled,
pub baselines: Baselines,
pub tolerances: Tolerances,
pub box_max_depth: Scaled,
}
impl ListBuilder {
pub fn new(mode: Mode) -> ListBuilder {
ListBuilder {
mode,
list: Vec::new(),
prev_depth: IGNORE_DEPTH,
baselines: Baselines::plain(),
tolerances: Tolerances::plain(),
box_max_depth: crate::node::MAX_DIMEN,
}
}
pub fn box_(&mut self, b: BoxNode) {
match self.mode {
Mode::Vertical => crate::pack::append_to_vlist(
&mut self.list,
b,
&mut self.prev_depth,
self.baselines,
),
Mode::Horizontal => self.list.push(Node::Box(b)),
}
}
pub fn rule(&mut self, rule: RuleNode) {
self.list.push(Node::Rule(rule));
if self.mode == Mode::Vertical {
self.prev_depth = IGNORE_DEPTH;
}
}
pub fn glue(&mut self, spec: Glue) {
self.list.push(Node::Glue(GlueNode::new(spec)));
}
pub fn leaders(&mut self, spec: Glue, kind: LeaderKind, leader: Node) {
self.list.push(Node::Glue(GlueNode {
spec,
kind,
leader: Some(Box::new(leader)),
..GlueNode::default()
}));
}
pub fn kern(&mut self, width: Scaled) {
self.list.push(Node::Kern {
width,
explicit: true,
});
}
pub fn penalty(&mut self, value: i64) {
self.list.push(Node::Penalty(value));
}
pub fn mark(&mut self, text: String) {
self.list.push(Node::Mark(text));
}
pub fn unbox(
&mut self,
registers: &mut dyn Registers,
n: u8,
copy: bool,
) -> Result<(), BoxError> {
let Some(b) = registers.box_register(n) else {
return Ok(());
};
let compatible = match self.mode {
Mode::Horizontal => !b.vertical,
Mode::Vertical => b.vertical,
};
if !compatible {
return Err(BoxError::IncompatibleList);
}
let contents = match copy {
true => b.list.clone(),
false => registers.take_box(n).map(|b| b.list).unwrap_or_default(),
};
self.list.extend(contents);
Ok(())
}
pub fn last_box(&mut self) -> Option<BoxNode> {
if !matches!(self.list.last(), Some(Node::Box(_))) {
return None;
}
if self.last_is_a_discretionarys_replacement() {
return None;
}
let Some(Node::Box(mut b)) = self.list.pop() else {
return None;
};
b.shift_amount = 0;
Some(b)
}
pub fn remove_last(&mut self, kind: Removable) -> Option<Node> {
let wanted = match kind {
Removable::Glue => 10,
Removable::Kern => 11,
Removable::Penalty => 12,
};
if self.list.last().map(Node::type_code) != Some(wanted) {
return None;
}
if self.last_is_a_discretionarys_replacement() {
return None;
}
self.list.pop()
}
fn last_is_a_discretionarys_replacement(&self) -> bool {
let Some(tail) = self.list.len().checked_sub(1) else {
return false;
};
for (i, node) in self.list.iter().enumerate() {
if let Node::Disc(d) = node {
if tail > i && tail <= i + d.replace_count {
return true;
}
}
}
false
}
pub fn package(self, kind: Kind, spec: Spec) -> Packed {
package(kind, self.list, spec, self.box_max_depth, self.tolerances)
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Removable {
Glue,
Kern,
Penalty,
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Dimension {
Width,
Height,
Depth,
}
pub fn box_dimen(registers: &dyn Registers, n: u8, which: Dimension) -> Scaled {
let Some(b) = registers.box_register(n) else {
return 0;
};
match which {
Dimension::Width => b.width,
Dimension::Height => b.height,
Dimension::Depth => b.depth,
}
}
pub fn set_box_dimen(registers: &mut dyn Registers, n: u8, which: Dimension, value: Scaled) {
let Some(mut b) = registers.take_box(n) else {
return;
};
match which {
Dimension::Width => b.width = value,
Dimension::Height => b.height = value,
Dimension::Depth => b.depth = value,
}
registers.set_box(n, Some(b));
}
pub fn vsplit_register(
registers: &mut dyn Registers,
n: u8,
height: Scaled,
split_max_depth: Scaled,
split_top_skip: Glue,
tol: Tolerances,
) -> Option<crate::page::Split> {
let boxed = registers.take_box(n)?;
let split = crate::page::vsplit(boxed, height, split_max_depth, split_top_skip, tol)?;
registers.set_box(n, split.remainder.clone());
Some(split)
}
pub fn vbox(list: Vec<Node>, tol: Tolerances) -> BoxNode {
vpack(list, crate::pack::NATURAL, tol).node
}
#[cfg(test)]
mod tests {
use super::*;
use crate::node::GlueSource;
use crate::pack::NATURAL;
fn pt(n: i64) -> Scaled {
n * UNITY
}
fn boxed(width: Scaled, height: Scaled, depth: Scaled, vertical: bool) -> BoxNode {
BoxNode {
width,
height,
depth,
vertical,
..BoxNode::null()
}
}
#[test]
fn raise_is_negative_and_lower_is_positive() {
let b = boxed(pt(10), pt(5), 0, false);
assert_eq!(raise(b.clone(), pt(3)).shift_amount, -pt(3));
assert_eq!(lower(b.clone(), pt(3)).shift_amount, pt(3));
assert_eq!(move_left(b.clone(), pt(3)).shift_amount, -pt(3));
assert_eq!(move_right(b, pt(3)).shift_amount, pt(3));
}
#[test]
fn a_raised_box_makes_the_line_taller() {
let inner = raise(boxed(pt(10), pt(5), pt(1), false), pt(3));
let packed = hpack(vec![Node::Box(inner)], NATURAL, Tolerances::plain(), None);
assert_eq!(packed.node.height, pt(8));
assert_eq!(packed.node.depth, 0);
let inner = lower(boxed(pt(10), pt(5), pt(1), false), pt(3));
let packed = hpack(vec![Node::Box(inner)], NATURAL, Tolerances::plain(), None);
assert_eq!(packed.node.depth, pt(4));
assert_eq!(packed.node.height, pt(2));
}
#[test]
fn the_rules_have_tex_s_own_defaults() {
let h = hrule();
assert_eq!(h.height, DEFAULT_RULE);
assert_eq!(h.depth, 0);
assert!(RuleNode::is_running(h.width));
assert_eq!(crate::dimen::print_scaled(DEFAULT_RULE), "0.4");
let v = vrule();
assert_eq!(v.width, DEFAULT_RULE);
assert!(RuleNode::is_running(v.height));
assert!(RuleNode::is_running(v.depth));
}
#[test]
fn a_rule_stops_the_next_baselineskip() {
let mut b = ListBuilder::new(Mode::Vertical);
b.box_(boxed(pt(100), pt(8), pt(2), false));
assert_eq!(b.prev_depth, pt(2));
b.rule(hrule());
assert_eq!(b.prev_depth, IGNORE_DEPTH);
b.box_(boxed(pt(100), pt(8), pt(2), false));
assert_eq!(b.list.len(), 3);
assert!(!b.list.iter().any(|n| matches!(n, Node::Glue(_))));
}
#[test]
fn two_boxes_in_a_row_do_get_interline_glue() {
let mut b = ListBuilder::new(Mode::Vertical);
b.box_(boxed(pt(100), pt(8), pt(2), false));
b.box_(boxed(pt(100), pt(8), pt(2), false));
assert_eq!(b.list.len(), 3);
let Node::Glue(g) = &b.list[1] else {
panic!("interline glue");
};
assert_eq!(g.source, GlueSource::BaselineSkip);
assert_eq!(g.spec.natural, pt(2));
}
#[test]
fn unboxing_spills_the_contents_and_copying_keeps_the_register() {
let mut regs = Boxes::default();
let inner = hpack(
vec![
Node::Glue(GlueNode::new(Glue::fixed(pt(3)))),
Node::Box(boxed(pt(10), 0, 0, false)),
],
NATURAL,
Tolerances::plain(),
None,
)
.node;
regs.set_box(0, Some(inner));
let mut b = ListBuilder::new(Mode::Horizontal);
b.unbox(&mut regs, 0, true).expect("an hbox in hmode");
assert_eq!(b.list.len(), 2);
assert!(regs.box_register(0).is_some());
b.unbox(&mut regs, 0, false).expect("an hbox in hmode");
assert_eq!(b.list.len(), 4);
assert!(regs.box_register(0).is_none());
b.unbox(&mut regs, 7, false).expect("a void register");
assert_eq!(b.list.len(), 4);
}
#[test]
fn unboxing_the_wrong_kind_of_box_is_refused() {
let mut regs = Boxes::default();
regs.set_box(0, Some(boxed(pt(10), 0, 0, false)));
let mut v = ListBuilder::new(Mode::Vertical);
assert_eq!(
v.unbox(&mut regs, 0, false),
Err(BoxError::IncompatibleList)
);
assert!(regs.box_register(0).is_some());
assert!(v.list.is_empty());
assert_eq!(
BoxError::IncompatibleList.to_string(),
"Incompatible list can't be unboxed"
);
}
#[test]
fn setting_a_box_dimension_does_not_move_what_is_in_it() {
let mut regs = Boxes::default();
let inner = hpack(
vec![Node::Box(boxed(pt(10), pt(4), pt(1), false))],
NATURAL,
Tolerances::plain(),
None,
)
.node;
regs.set_box(0, Some(inner));
assert_eq!(box_dimen(®s, 0, Dimension::Width), pt(10));
set_box_dimen(&mut regs, 0, Dimension::Width, 0);
assert_eq!(box_dimen(®s, 0, Dimension::Width), 0);
let b = regs.box_register(0).expect("still a box");
assert_eq!(b.list.len(), 1);
assert_eq!(b.height, pt(4));
assert_eq!(box_dimen(®s, 9, Dimension::Height), 0);
set_box_dimen(&mut regs, 9, Dimension::Height, pt(5));
assert!(regs.box_register(9).is_none());
}
#[test]
fn hss_shrinks_where_hfil_only_stretches() {
let line = |spec: Glue| {
vec![
Node::Glue(GlueNode::new(spec)),
Node::Box(boxed(pt(50), 0, 0, false)),
Node::Glue(GlueNode::new(spec)),
]
};
let packed = hpack(
line(fill::fil()),
Spec::Exactly(pt(40)),
Tolerances::plain(),
None,
);
assert_eq!(packed.report, Some(crate::pack::Report::Overfull(pt(10))));
let packed = hpack(
line(fill::ss()),
Spec::Exactly(pt(40)),
Tolerances::plain(),
None,
);
assert_eq!(packed.report, None);
let widths = crate::pack::glue_widths(&packed.node);
assert_eq!(widths, vec![-pt(5), -pt(5)]);
}
#[test]
fn hfil_on_both_sides_centres_a_box() {
let list = vec![
Node::Glue(GlueNode::new(fill::fil())),
Node::Box(boxed(pt(50), 0, 0, false)),
Node::Glue(GlueNode::new(fill::fil())),
];
let packed = hpack(list, Spec::Exactly(pt(101)), Tolerances::plain(), None);
let widths = crate::pack::glue_widths(&packed.node);
assert_eq!(widths.len(), 2);
assert_eq!(widths[0] + widths[1], pt(51));
assert_eq!(widths[0], pt(51) / 2);
}
#[test]
fn hfilneg_cancels_an_hfil() {
let list = vec![
Node::Glue(GlueNode::new(fill::fil())),
Node::Glue(GlueNode::new(fill::fil_neg())),
Node::Box(boxed(pt(10), 0, 0, false)),
];
let packed = hpack(list, Spec::Exactly(pt(30)), Tolerances::plain(), None);
assert_eq!(packed.node.glue_sign, crate::node::GlueSign::Normal);
assert_eq!(packed.node.width, pt(30));
}
#[test]
fn hbox_vbox_and_vtop_put_the_reference_point_in_three_places() {
let list = || {
vec![
Node::Box(boxed(pt(30), pt(7), pt(2), false)),
Node::Box(boxed(pt(40), pt(5), pt(3), false)),
]
};
let h = package(
Kind::H,
list(),
NATURAL,
crate::node::MAX_DIMEN,
Tolerances::plain(),
);
assert_eq!(h.node.width, pt(70));
assert_eq!(h.node.height, pt(7));
assert_eq!(h.node.depth, pt(3));
let v = package(
Kind::V,
list(),
NATURAL,
crate::node::MAX_DIMEN,
Tolerances::plain(),
);
assert_eq!(v.node.width, pt(40));
assert_eq!(v.node.height, pt(14));
assert_eq!(v.node.depth, pt(3));
let t = package(
Kind::Top,
list(),
NATURAL,
crate::node::MAX_DIMEN,
Tolerances::plain(),
);
assert_eq!(t.node.height, pt(7));
assert_eq!(t.node.depth, pt(10));
assert_eq!(
t.node.height + t.node.depth,
v.node.height + v.node.depth,
"a vtop is the same material, measured from a different point"
);
}
#[test]
fn vsplit_leaves_the_remainder_in_the_register() {
let mut regs = Boxes::default();
let mut list = Vec::new();
for i in 0..6 {
if i > 0 {
list.push(Node::Glue(GlueNode::new(Glue {
natural: pt(2),
stretch: pt(1),
shrink: pt(1),
..Glue::default()
})));
}
list.push(Node::Box(boxed(pt(100), pt(10), 0, false)));
}
regs.set_box(1, Some(vbox(list, Tolerances::plain())));
let split = vsplit_register(
&mut regs,
1,
pt(34),
pt(4),
Glue::fixed(pt(10)),
Tolerances::plain(),
)
.expect("a vbox splits");
assert_eq!(split.extracted.height, pt(34));
let rest = regs.box_register(1).expect("the remainder stayed behind");
assert!(rest.vertical);
assert!(rest.height > pt(20));
}
#[test]
fn lastbox_takes_the_box_and_forgets_where_it_sat() {
let mut b = ListBuilder::new(Mode::Horizontal);
b.box_(boxed(pt(10), pt(3), 0, false));
b.box_(raise(boxed(pt(20), pt(3), 0, false), pt(5)));
let taken = b.last_box().expect("the list ends with a box");
assert_eq!(taken.width, pt(20));
assert_eq!(taken.shift_amount, 0, "the raise did not come with it");
assert_eq!(b.list.len(), 1);
assert_eq!(b.last_box().map(|b| b.width), Some(pt(10)));
assert!(b.last_box().is_none());
}
#[test]
fn lastbox_is_void_when_the_list_does_not_end_with_one() {
let mut b = ListBuilder::new(Mode::Horizontal);
b.box_(boxed(pt(10), pt(3), 0, false));
b.glue(Glue::fixed(pt(4)));
assert!(b.last_box().is_none());
assert_eq!(b.list.len(), 2, "the glue is still there");
b.rule(vrule());
assert!(b.last_box().is_none(), "a rule is not a box");
}
#[test]
fn a_discretionarys_replacement_is_not_the_lists_to_take() {
let mut b = ListBuilder::new(Mode::Horizontal);
b.list.push(Node::Disc(crate::node::DiscNode {
pre_break: Vec::new(),
post_break: Vec::new(),
replace_count: 1,
}));
b.box_(boxed(pt(10), pt(3), 0, false));
assert!(b.last_box().is_none());
assert_eq!(b.list.len(), 2);
}
#[test]
fn unskip_unkern_and_unpenalty_each_take_only_their_own_kind() {
let mut b = ListBuilder::new(Mode::Horizontal);
b.box_(boxed(pt(10), pt(3), 0, false));
b.glue(Glue::fixed(pt(4)));
b.kern(pt(2));
b.penalty(150);
assert!(
b.remove_last(Removable::Glue).is_none(),
"a penalty is not glue"
);
assert!(matches!(
b.remove_last(Removable::Penalty),
Some(Node::Penalty(150))
));
assert!(matches!(
b.remove_last(Removable::Kern),
Some(Node::Kern { width, .. }) if width == pt(2)
));
assert!(matches!(
b.remove_last(Removable::Glue),
Some(Node::Glue(_))
));
assert!(b.remove_last(Removable::Glue).is_none());
assert_eq!(b.list.len(), 1);
}
}