page.rs

//! 縦の並びをページに割り付ける
//!
//! 上から順に積み、入らなくなったら直前の切れ目まで戻して切る。脚注はそれを載せる行と
//! 同じページに置き、そのぶん本文に使える高さが減る。
//!
//! 浮かせるものは、収まる最初のページの先頭に置く。`[h]` と書いてあって、その場に
//! 入るときだけはそこに置く。1 ページに使ってよい割合は [`Style::float_fraction`] で決める。

use crate::draw::{self, Letter, Mark, Page};
use crate::font::{self, Library};
use crate::layout::{Block, Note};
use crate::line;
use crate::number::Numbering;
use crate::pdf::Destination;
use crate::style::{self, Style};


/// まだ置いていない浮かせるもの
#[derive(Debug, Clone)]
struct Waiting {
    mark: Vec<Mark>,
    height: f64,
    anchor: Vec<String>,
}


/// 縦の並びをページに割り付ける
pub fn paginate(
    block: &[Block],
    library: &Library,
    style: &Style,
    numbering: &mut Numbering,
) -> (Vec<Page>, Vec<Destination>) {
    let goal = style::body_height(style);
    let mut out: Vec<Page> = Vec::new();
    let mut destination = Vec::new();
    let mut waiting: Vec<Waiting> = Vec::new();
    let mut at = 0;

    while at < block.len() || !waiting.is_empty() {
        let number = out.len();
        let (top, float_height) = take_floats(&mut waiting, style, goal);
        let room = goal - float_height;
        // 浮かせたものだけでページが埋まったら、本文はこのページには入れない
        let (placed, note, end) = if room < style.leading {
            (Vec::new(), Vec::new(), at)
        } else {
            take_body(block, at, room, style, &mut waiting)
        };
        let mut mark = Vec::new();
        let mut y = 0.0;

        for one in &top {
            let mut copy = one.mark.clone();
            draw::shift(&mut copy, style.margin_left, style.margin_top + y);
            mark.extend(copy);
            remember(numbering, &one.anchor, number + 1);
            y += one.height + style.float_gap;
        }

        for (index, offset) in &placed {
            let at_y = style.margin_top + float_height + offset;

            match &block[*index] {
                Block::Content {mark: inner, anchor, heading, ..} => {
                    let mut copy = inner.clone();
                    draw::shift(&mut copy, style.margin_left, at_y);
                    mark.extend(copy);
                    remember(numbering, anchor, number + 1);

                    if let Some((level, title)) = heading {
                        destination.push(Destination {
                            level: *level,
                            title: title.clone(),
                            page: number,
                        });
                    }
                }
                Block::Float {mark: inner, anchor, ..} => {
                    let mut copy = inner.clone();
                    draw::shift(&mut copy, style.margin_left, at_y);
                    mark.extend(copy);
                    remember(numbering, anchor, number + 1);
                }
                _ => {}
            }
        }

        if !note.is_empty() {
            place_notes(&mut mark, &note, style, goal);
        }

        if style.page_number {
            mark.extend(page_number(library, style, number + 1));
        }

        out.push(Page {
            mark,
            width: style.page_width,
            height: style.page_height,
        });

        at = if end == at && top.is_empty() && at < block.len() {
            at + 1
        } else {
            end
        };
    }

    if out.is_empty() {
        out.push(Page {
            mark: Vec::new(),
            width: style.page_width,
            height: style.page_height,
        });
    }

    (out, destination)
}


/// 名前とページ番号を結び付ける
fn remember(numbering: &mut Numbering, anchor: &[String], page: usize) {
    for name in anchor {
        numbering.page.insert(name.clone(), page);
    }
}


/// このページの先頭に置く浮かせるものを取る
fn take_floats(waiting: &mut Vec<Waiting>, style: &Style, goal: f64) -> (Vec<Waiting>, f64) {
    let budget = goal * style.float_fraction;
    let mut top = Vec::new();
    let mut height = 0.0;

    while !waiting.is_empty() {
        let want = waiting[0].height + style.float_gap;

        if top.is_empty() && want > goal {
            // 1 つでページに入らないものは、そのページを丸ごと使う
            height += want;
            top.push(waiting.remove(0));

            break;
        }

        if height + want > budget {
            break;
        }

        height += want;
        top.push(waiting.remove(0));
    }

    (top, height)
}


/// このページに入れる本文を決める
fn take_body(
    block: &[Block],
    from: usize,
    room: f64,
    style: &Style,
    waiting: &mut Vec<Waiting>,
) -> (Vec<(usize, f64)>, Vec<Note>, usize) {
    let mut placed: Vec<(usize, f64)> = Vec::new();
    let mut note: Vec<Note> = Vec::new();
    let mut used = 0.0;
    let mut mark: Option<(usize, usize, usize)> = None;
    let mut at = from;
    let mut forced = false;

    while at < block.len() {
        match &block[at] {
            Block::NewPage => {
                at += 1;
                forced = true;

                break;
            }
            Block::Break {penalty} => {
                if *penalty < line::FORBIDDEN && !placed.is_empty() {
                    mark = Some((at, placed.len(), note.len()));
                }

                at += 1;
            }
            Block::Space {height, ..} => {
                if !placed.is_empty() {
                    used += height;
                }

                at += 1;
            }
            Block::Float {placement, mark: inner, height, anchor} => {
                let here = placement.contains('h') || placement.contains('H');
                // その場に置くときも、本文とのあいだは空ける
                let lead = if placed.is_empty() {0.0} else {style.float_gap};
                let want = lead + height + style.float_gap + note_area(&note, style);

                if here && used + want <= room {
                    used += lead;
                    placed.push((at, used));
                    used += height + style.float_gap;

                } else {
                    waiting.push(Waiting {
                        mark: inner.clone(),
                        height: *height,
                        anchor: anchor.clone(),
                    });
                }

                at += 1;
            }
            Block::Content {height, note: mine, ..} => {
                let mut after = note.clone();
                after.extend(mine.iter().cloned());
                let total = used + height + note_area(&after, style);

                if total > room && !placed.is_empty() {
                    break;
                }

                placed.push((at, used));
                used += height;
                note = after;
                at += 1;
            }
        }
    }

    if at >= block.len() || forced {
        return (placed, note, at);
    }

    match mark {
        Some((index, keep, note_keep)) => {
            placed.truncate(keep);
            note.truncate(note_keep);

            (placed, note, index + 1)
        }
        None => (placed, note, at),
    }
}


/// 脚注の欄が取る高さ
fn note_area(note: &[Note], style: &Style) -> f64 {
    if note.is_empty() {
        return 0.0;
    }

    style.footnote_gap + note.iter().map(|one| one.height).sum::<f64>()
}


/// 脚注をページの下に置く
fn place_notes(mark: &mut Vec<Mark>, note: &[Note], style: &Style, goal: f64) {
    let total: f64 = note.iter().map(|one| one.height).sum();
    let base = style.margin_top + goal - total;
    mark.push(Mark::Rule {
        x: style.margin_left,
        y: base - style.footnote_gap * 0.6,
        width: style.footnote_rule,
        height: style.rule_width,
    });
    let mut y = base;

    for one in note {
        let mut copy = one.mark.clone();
        draw::shift(&mut copy, style.margin_left, y);
        mark.extend(copy);
        y += one.height;
    }
}


/// ノンブルを置く
fn page_number(library: &Library, style: &Style, number: usize) -> Vec<Mark> {
    let index = library.role.roman;
    let face = &library.face[index];
    let size = style.size * 0.9;
    let mut letter = Vec::new();
    let mut width = 0.0;

    for character in number.to_string().chars() {
        if let Some(glyph) = font::glyph(face, character) {
            width += font::advance(face, glyph) * size;
            letter.push(Letter {glyph, text: character.to_string()});
        }
    }

    if letter.is_empty() {
        return Vec::new();
    }

    vec![Mark::Text {
        face: index,
        size,
        stretch: 1.0,
        x: style.page_width / 2.0 - width / 2.0,
        y: style.page_height - style.margin_bottom * 0.45,
        letter,
    }]
}