use crate::dvi::Writer;
use crate::glue::{Glue, Order};
use crate::node::{BoxNode, CharNode, GlueSign, LeaderKind, Node, RuleNode, Scaled};
fn dvi_scaled(x: Scaled) -> i32 {
x.clamp(i32::MIN as Scaled, i32::MAX as Scaled) as i32
}
fn vet_glue(x: f64) -> f64 {
x.clamp(-1_000_000_000.0, 1_000_000_000.0)
}
pub struct Shipper<'a> {
w: &'a mut Writer,
dvi_h: Scaled,
dvi_v: Scaled,
cur_h: Scaled,
cur_v: Scaled,
dvi_f: Option<usize>,
cur_s: i32,
doing_leaders: bool,
}
pub fn ship_out(
w: &mut Writer,
page: &BoxNode,
counts: [i32; 10],
h_offset: Scaled,
v_offset: Scaled,
) {
w.begin_page(counts);
let mut ship = Shipper {
w,
dvi_h: 0,
dvi_v: 0,
cur_h: h_offset,
cur_v: 0,
dvi_f: None,
cur_s: -1,
doing_leaders: false,
};
ship.cur_v = page.height + v_offset;
match page.vertical {
true => ship.vlist_out(page),
false => ship.hlist_out(page),
}
ship.w.end_page();
}
impl Shipper<'_> {
fn synch_h(&mut self) {
if self.cur_h != self.dvi_h {
self.w.right(dvi_scaled(self.cur_h - self.dvi_h));
self.dvi_h = self.cur_h;
}
}
fn synch_v(&mut self) {
if self.cur_v != self.dvi_v {
self.w.down(dvi_scaled(self.cur_v - self.dvi_v));
self.dvi_v = self.cur_v;
}
}
fn synch_font(&mut self, f: usize) {
if self.dvi_f != Some(f) {
self.w.font(f as u32);
self.dvi_f = Some(f);
}
}
fn out_char(&mut self, c: &CharNode) {
self.synch_font(c.font);
self.w.set_char(c.character as u32, dvi_scaled(c.width));
self.cur_h += c.width;
}
pub fn hlist_out(&mut self, this_box: &BoxNode) {
let g_order = this_box.glue_order;
let g_sign = this_box.glue_sign;
let mut cur_glue = 0.0f64;
let mut cur_g: Scaled = 0;
self.cur_s += 1;
if self.cur_s > 0 {
self.w.push();
}
let base_line = self.cur_v;
let left_edge = self.cur_h;
let mut i = 0;
while i < this_box.list.len() {
let p = &this_box.list[i];
if let Node::Char(c) | Node::Ligature(c) = p {
self.synch_h();
self.synch_v();
let mut c = c;
loop {
self.out_char(c);
i += 1;
match this_box.list.get(i) {
Some(Node::Char(next) | Node::Ligature(next)) => c = next,
_ => break,
}
}
self.dvi_h = self.cur_h;
continue;
}
let rule_wd = match p {
Node::Box(b) => {
if b.list.is_empty() {
self.cur_h += b.width;
} else {
let (save_h, save_v) = (self.dvi_h, self.dvi_v);
self.cur_v = base_line + b.shift_amount;
let edge = self.cur_h;
match b.vertical {
true => self.vlist_out(b),
false => self.hlist_out(b),
}
self.dvi_h = save_h;
self.dvi_v = save_v;
self.cur_h = edge + b.width;
self.cur_v = base_line;
}
i += 1;
continue;
}
Node::Rule(r) => self.hrule_out(r, this_box, base_line),
Node::Whatsit(text) => {
self.synch_h();
self.synch_v();
self.w.special(text);
i += 1;
continue;
}
Node::Glue(g) => {
let mut rule_wd = g.spec.natural - cur_g;
set_glue(
&g.spec,
g_sign,
g_order,
this_box.glue_set,
&mut cur_glue,
&mut cur_g,
);
rule_wd += cur_g;
match (g.kind.is_leaders(), g.leader.as_deref()) {
(true, Some(Node::Rule(r))) => {
let over = RuleNode {
width: rule_wd,
height: r.height,
depth: r.depth,
};
self.hrule_out(&over, this_box, base_line)
}
(true, Some(Node::Box(b))) => {
self.hleaders_out(g.kind, b, rule_wd, left_edge, base_line)
}
_ => rule_wd,
}
}
Node::Kern { width, .. } | Node::Math(width) => *width,
_ => 0,
};
self.cur_h += rule_wd;
i += 1;
}
if self.cur_s > 0 {
self.w.pop();
}
self.cur_s -= 1;
}
fn hrule_out(&mut self, r: &RuleNode, this_box: &BoxNode, base_line: Scaled) -> Scaled {
let rule_wd = r.width;
let mut rule_ht = r.height;
let mut rule_dp = r.depth;
if RuleNode::is_running(rule_ht) {
rule_ht = this_box.height;
}
if RuleNode::is_running(rule_dp) {
rule_dp = this_box.depth;
}
rule_ht += rule_dp;
if rule_ht > 0 && rule_wd > 0 {
self.synch_h();
self.cur_v = base_line + rule_dp;
self.synch_v();
self.w.rule(dvi_scaled(rule_ht), dvi_scaled(rule_wd), true);
self.cur_v = base_line;
self.dvi_h += rule_wd;
}
rule_wd
}
fn hleaders_out(
&mut self,
kind: LeaderKind,
leader_box: &BoxNode,
rule_wd: Scaled,
left_edge: Scaled,
base_line: Scaled,
) -> Scaled {
let leader_wd = leader_box.width;
if leader_wd <= 0 || rule_wd <= 0 {
return rule_wd;
}
let rule_wd = rule_wd + 10;
let edge = self.cur_h + rule_wd;
let mut lx: Scaled = 0;
match kind {
LeaderKind::Aligned => {
let save_h = self.cur_h;
self.cur_h = left_edge + leader_wd * ((self.cur_h - left_edge) / leader_wd);
if self.cur_h < save_h {
self.cur_h += leader_wd;
}
}
_ => {
let lq = rule_wd / leader_wd;
let lr = rule_wd % leader_wd;
match kind {
LeaderKind::Centred => self.cur_h += lr / 2,
_ => {
lx = lr / (lq + 1);
self.cur_h += (lr - (lq - 1) * lx) / 2;
}
}
}
}
while self.cur_h + leader_wd <= edge {
self.cur_v = base_line + leader_box.shift_amount;
self.synch_v();
let save_v = self.dvi_v;
self.synch_h();
let save_h = self.dvi_h;
let outer = self.doing_leaders;
self.doing_leaders = true;
match leader_box.vertical {
true => self.vlist_out(leader_box),
false => self.hlist_out(leader_box),
}
self.doing_leaders = outer;
self.dvi_v = save_v;
self.dvi_h = save_h;
self.cur_v = base_line;
self.cur_h = save_h + leader_wd + lx;
}
edge - 10 - self.cur_h
}
pub fn vlist_out(&mut self, this_box: &BoxNode) {
let g_order = this_box.glue_order;
let g_sign = this_box.glue_sign;
let mut cur_glue = 0.0f64;
let mut cur_g: Scaled = 0;
self.cur_s += 1;
if self.cur_s > 0 {
self.w.push();
}
let left_edge = self.cur_h;
self.cur_v -= this_box.height;
let top_edge = self.cur_v;
for p in &this_box.list {
let rule_ht = match p {
Node::Box(b) => {
if b.list.is_empty() {
self.cur_v += b.height + b.depth;
} else {
self.cur_v += b.height;
self.synch_v();
let (save_h, save_v) = (self.dvi_h, self.dvi_v);
self.cur_h = left_edge + b.shift_amount;
match b.vertical {
true => self.vlist_out(b),
false => self.hlist_out(b),
}
self.dvi_h = save_h;
self.dvi_v = save_v;
self.cur_v = save_v + b.depth;
self.cur_h = left_edge;
}
continue;
}
Node::Rule(r) => {
self.vrule_out(r, this_box);
continue;
}
Node::Whatsit(text) => {
self.synch_h();
self.synch_v();
self.w.special(text);
continue;
}
Node::Glue(g) => {
let mut rule_ht = g.spec.natural - cur_g;
set_glue(
&g.spec,
g_sign,
g_order,
this_box.glue_set,
&mut cur_glue,
&mut cur_g,
);
rule_ht += cur_g;
match (g.kind.is_leaders(), g.leader.as_deref()) {
(true, Some(Node::Rule(r))) => {
let over = RuleNode {
width: r.width,
height: rule_ht,
depth: 0,
};
self.vrule_out(&over, this_box);
continue;
}
(true, Some(Node::Box(b))) => {
self.vleaders_out(g.kind, b, rule_ht, left_edge, top_edge)
}
_ => rule_ht,
}
}
Node::Kern { width, .. } => *width,
_ => 0,
};
self.cur_v += rule_ht;
}
if self.cur_s > 0 {
self.w.pop();
}
self.cur_s -= 1;
}
fn vrule_out(&mut self, r: &RuleNode, this_box: &BoxNode) {
let mut rule_wd = r.width;
if RuleNode::is_running(rule_wd) {
rule_wd = this_box.width;
}
let rule_ht = r.height + r.depth;
self.cur_v += rule_ht;
if rule_ht > 0 && rule_wd > 0 {
self.synch_h();
self.synch_v();
self.w.rule(dvi_scaled(rule_ht), dvi_scaled(rule_wd), false);
}
}
fn vleaders_out(
&mut self,
kind: LeaderKind,
leader_box: &BoxNode,
rule_ht: Scaled,
left_edge: Scaled,
top_edge: Scaled,
) -> Scaled {
let leader_ht = leader_box.height + leader_box.depth;
if leader_ht <= 0 || rule_ht <= 0 {
return rule_ht;
}
let rule_ht = rule_ht + 10;
let edge = self.cur_v + rule_ht;
let mut lx: Scaled = 0;
match kind {
LeaderKind::Aligned => {
let save_v = self.cur_v;
self.cur_v = top_edge + leader_ht * ((self.cur_v - top_edge) / leader_ht);
if self.cur_v < save_v {
self.cur_v += leader_ht;
}
}
_ => {
let lq = rule_ht / leader_ht;
let lr = rule_ht % leader_ht;
match kind {
LeaderKind::Centred => self.cur_v += lr / 2,
_ => {
lx = lr / (lq + 1);
self.cur_v += (lr - (lq - 1) * lx) / 2;
}
}
}
}
while self.cur_v + leader_ht <= edge {
self.cur_h = left_edge + leader_box.shift_amount;
self.synch_h();
let save_h = self.dvi_h;
self.cur_v += leader_box.height;
self.synch_v();
let save_v = self.dvi_v;
let outer = self.doing_leaders;
self.doing_leaders = true;
match leader_box.vertical {
true => self.vlist_out(leader_box),
false => self.hlist_out(leader_box),
}
self.doing_leaders = outer;
self.dvi_v = save_v;
self.dvi_h = save_h;
self.cur_h = left_edge;
self.cur_v = save_v - leader_box.height + leader_ht + lx;
}
edge - 10 - self.cur_v
}
}
fn set_glue(
spec: &Glue,
g_sign: GlueSign,
g_order: Order,
glue_set: f64,
cur_glue: &mut f64,
cur_g: &mut Scaled,
) {
match g_sign {
GlueSign::Normal => {}
GlueSign::Stretching if spec.stretch_order == g_order => {
*cur_glue += spec.stretch as f64;
*cur_g = vet_glue(glue_set * *cur_glue).round() as Scaled;
}
GlueSign::Shrinking if spec.shrink_order == g_order => {
*cur_glue -= spec.shrink as f64;
*cur_g = vet_glue(glue_set * *cur_glue).round() as Scaled;
}
_ => {}
}
}