slide.rs

//! スライド 1 枚
//!
//! スライドは図形の並びである。文字は図形の中に入っていて、図形の外に文字は置けない。
//! 図形には差し込み口 (`<p:ph>`) の種類が付いていることがあり、題名や本文はそれで見分ける。
//!
//! # 段落は docx と別の型にしてある
//!
//! docx の段落は書式の名前を持ち、pptx の段落は箇条書きの深さを持つ。持ち物が違うので分けてある。
//! 中の [`Run`] は同じものを使う。

use crate::error::Error;
use crate::paragraph::{Align, Run};
use crate::xml::{self, Event, Reader};


/// 1 インチあたりの長さ。pptx の位置と大きさはこの単位で入っている
pub const INCH: i64 = 914400;


/// スライドの段落
#[derive(Debug, Clone, Default, PartialEq)]
pub struct Paragraph {
    /// 箇条書きの深さ。0 がいちばん浅い
    pub level: u32,
    /// 行のそろえ方
    pub align: Align,
    /// 中身
    pub run: Vec<Run>,
}


impl Paragraph {
    /// 飾りのない 1 行
    pub fn new(text: &str) -> Paragraph {
        Paragraph {run: vec![Run::new(text)], ..Paragraph::default()}
    }

    /// 深さを指定した 1 行
    pub fn nested(text: &str, level: u32) -> Paragraph {
        Paragraph {level, run: vec![Run::new(text)], ..Paragraph::default()}
    }

    /// 中の続きをつないだ文字
    pub fn text(&self) -> String {
        let mut result = String::new();

        for one in &self.run {
            result.push_str(&one.text);
        }

        result
    }
}


/// スライドに置かれたもの
#[derive(Debug, Clone, Default, PartialEq)]
pub struct Shape {
    /// 図形の名前
    pub name: String,
    /// 差し込み口の種類 (title、body、subTitle など)。ないときは空
    pub place: String,
    /// 左上の位置。[`INCH`] 単位。分からないときは 0
    pub x: i64,
    pub y: i64,
    /// 大きさ。[`INCH`] 単位。分からないときは 0
    pub width: i64,
    pub height: i64,
    /// 中の段落
    pub paragraph: Vec<Paragraph>,
}


impl Shape {
    /// 位置と大きさを決めた、文字だけの図形
    pub fn text(name: &str, x: i64, y: i64, width: i64, height: i64, line: &[&str]) -> Shape {
        Shape {
            name: name.to_string(),
            place: String::new(),
            x,
            y,
            width,
            height,
            paragraph: line.iter().map(|one| Paragraph::new(one)).collect(),
        }
    }

    /// 中の文字を、段落ごとに改行でつないで返す
    pub fn body(&self) -> String {
        let mut result = String::new();

        for one in &self.paragraph {
            if !result.is_empty() {
                result.push('\n');
            }

            result.push_str(&one.text());
        }

        result
    }
}


/// スライド 1 枚
#[derive(Debug, Clone, Default, PartialEq)]
pub struct Slide {
    pub shape: Vec<Shape>,
}


impl Slide {
    /// 図形を並べたスライド
    pub fn new(shape: Vec<Shape>) -> Slide {
        Slide {shape}
    }

    /// 中の文字を、図形ごとに改行でつないで返す
    pub fn text(&self) -> String {
        let mut result = String::new();

        for one in &self.shape {
            let body = one.body();

            if body.is_empty() {
                continue;
            }

            if !result.is_empty() {
                result.push('\n');
            }

            result.push_str(&body);
        }

        result
    }
}


/// スライドのパートを読む
///
/// 組にまとめられた図形 (`<p:grpSp>`) の中身も、同じ並びに入れて返す。
pub fn read(source: &mut Reader) -> Result<Slide, Error> {
    let mut result = Slide::default();

    while let Some(event) = source.next()? {
        if event != Event::Open {
            continue;
        }

        match source.name() {
            "sp" => result.shape.push(read_shape(source, "sp")?),
            "pic" => result.shape.push(read_shape(source, "pic")?),
            "graphicFrame" => result.shape.push(read_shape(source, "graphicFrame")?),
            _ => {}
        }
    }

    Ok(result)
}


/// 図形 1 つを、閉じる印まで読む
fn read_shape(source: &mut Reader, close: &str) -> Result<Shape, Error> {
    let mut result = Shape::default();
    let mut named = false;
    let mut placed = false;
    let mut sized = false;

    while let Some(event) = source.next()? {
        if event == Event::Close {
            if source.name() == close {
                return Ok(result);
            }

            continue;
        }

        if event == Event::Text {
            continue;
        }

        match source.name() {
            // 図形の名前は最初の cNvPr に入っている。中の図の名前ではない
            "cNvPr" if !named => {
                result.name = source.attribute("name").unwrap_or("").to_string();
                named = true;
            }

            "ph" if !placed => {
                result.place = source.attribute("type").unwrap_or("body").to_string();
                placed = true;
            }

            "off" if !sized => {
                result.x = number(source.attribute("x"));
                result.y = number(source.attribute("y"));
            }

            "ext" if !sized => {
                result.width = number(source.attribute("cx"));
                result.height = number(source.attribute("cy"));
                sized = true;
            }

            "p" if event == Event::Open => result.paragraph.push(read_paragraph(source)?),
            _ => {}
        }
    }

    Ok(result)
}


/// `<a:p>` を読んだ直後から `</a:p>` まで読む
fn read_paragraph(source: &mut Reader) -> Result<Paragraph, Error> {
    let mut result = Paragraph::default();
    let mut decorating = false;
    let mut reading = false;
    let mut coloring = false;
    let mut run: Option<Run> = None;

    while let Some(event) = source.next()? {
        if event == Event::Text {
            if reading {
                if let Some(one) = run.as_mut() {
                    one.text.push_str(source.text());
                }
            }

            continue;
        }

        if event == Event::Close {
            match source.name() {
                "p" => {
                    if let Some(one) = run.take() {
                        result.run.push(one);
                    }

                    return Ok(result);
                }

                "rPr" | "defRPr" => decorating = false,
                "solidFill" => coloring = false,
                "t" => reading = false,

                "r" | "fld" => {
                    if let Some(one) = run.take() {
                        result.run.push(one);
                    }
                }

                _ => {}
            }

            continue;
        }

        let empty = event == Event::Empty;

        match source.name() {
            "pPr" => {
                result.level = number(source.attribute("lvl")) as u32;
                result.align = align(source.attribute("algn"));
            }

            "r" | "fld" => run = Some(Run::default()),

            "rPr" => {
                if let Some(one) = run.as_mut() {
                    decorate(one, source);
                }

                decorating = !empty && run.is_some();
            }

            "t" if run.is_some() => reading = !empty,
            "solidFill" if decorating => coloring = true,

            "srgbClr" if coloring => {
                if let Some(one) = run.as_mut() {
                    one.color = source.attribute("val").unwrap_or("").to_string();
                }
            }

            "latin" if decorating => {
                if let Some(one) = run.as_mut() {
                    one.font = source.attribute("typeface").unwrap_or("").to_string();
                }
            }

            "br" => {
                match result.run.last_mut() {
                    Some(one) => one.text.push('\n'),
                    None => result.run.push(Run::new("\n")),
                }
            }

            _ => {}
        }
    }

    Ok(result)
}


/// `<a:rPr>` の属性を読む
fn decorate(run: &mut Run, source: &Reader) {
    run.bold = flag(source.attribute("b"));
    run.italic = flag(source.attribute("i"));
    run.strike = matches!(source.attribute("strike"), Some("sngStrike") | Some("dblStrike"));
    run.underline = !matches!(source.attribute("u"), None | Some("none"));

    // 大きさは 100 分の 1 ポイントで入っている
    run.size = number(source.attribute("sz")) as f64 / 100.0;
}


/// `b="1"` のような印を読む
fn flag(value: Option<&str>) -> bool {
    matches!(value, Some("1") | Some("true"))
}


/// 数として読む。読めなければ 0
fn number(value: Option<&str>) -> i64 {
    match value {
        Some(text) => text.trim().parse().unwrap_or(0),
        None => 0,
    }
}


/// `algn="ctr"` を読む
fn align(value: Option<&str>) -> Align {
    match value {
        Some("l") => Align::Left,
        Some("ctr") => Align::Center,
        Some("r") => Align::Right,
        Some("just") | Some("dist") => Align::Justify,
        _ => Align::None,
    }
}


/// `algn` に書く形
fn align_name(value: Align) -> Option<&'static str> {
    match value {
        Align::None => None,
        Align::Left => Some("l"),
        Align::Center => Some("ctr"),
        Align::Right => Some("r"),
        Align::Justify => Some("just"),
    }
}


/// 図形の並びを XML にして足す
pub fn shape_into(result: &mut String, shape: &[Shape]) {
    for (index, one) in shape.iter().enumerate() {
        // 1 番は図形をまとめる入れ物が使うので、2 番から振る
        let id = index + 2;
        result.push_str(&format!("<p:sp><p:nvSpPr><p:cNvPr id=\"{id}\" name=\""));
        xml::escape_into(&one.name, result);
        result.push_str("\"/><p:cNvSpPr><a:spLocks noGrp=\"1\"/></p:cNvSpPr><p:nvPr>");

        if !one.place.is_empty() {
            result.push_str("<p:ph type=\"");
            xml::escape_into(&one.place, result);
            result.push_str("\"/>");
        }

        result.push_str("</p:nvPr></p:nvSpPr><p:spPr><a:xfrm>");
        result.push_str(&format!("<a:off x=\"{}\" y=\"{}\"/>", one.x, one.y));
        result.push_str(&format!("<a:ext cx=\"{}\" cy=\"{}\"/>", one.width, one.height));
        result.push_str("</a:xfrm><a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom></p:spPr>");
        result.push_str("<p:txBody><a:bodyPr wrap=\"square\"><a:normAutofit/></a:bodyPr><a:lstStyle/>");

        // 文字の入れ物には段落が 1 つ以上必要である
        if one.paragraph.is_empty() {
            result.push_str("<a:p/>");
        }

        for line in &one.paragraph {
            paragraph_into(result, line);
        }

        result.push_str("</p:txBody></p:sp>");
    }
}


/// 段落を XML にして足す
fn paragraph_into(result: &mut String, one: &Paragraph) {
    result.push_str("<a:p>");
    let align = align_name(one.align);

    if one.level > 0 || align.is_some() {
        result.push_str("<a:pPr");

        if one.level > 0 {
            result.push_str(&format!(" lvl=\"{}\"", one.level));
        }

        if let Some(name) = align {
            result.push_str(&format!(" algn=\"{name}\""));
        }

        result.push_str("/>");
    }

    for run in &one.run {
        run_into(result, run);
    }

    result.push_str("</a:p>");
}


/// 続きの文字を XML にして足す
fn run_into(result: &mut String, run: &Run) {
    // 改行は文字ではなく印として置く
    let mut first = true;

    for piece in run.text.split('\n') {
        if !first {
            result.push_str("<a:br/>");
        }

        first = false;

        if piece.is_empty() {
            continue;
        }

        result.push_str("<a:r><a:rPr lang=\"ja-JP\"");

        if run.bold {
            result.push_str(" b=\"1\"");
        }

        if run.italic {
            result.push_str(" i=\"1\"");
        }

        if run.underline {
            result.push_str(" u=\"sng\"");
        }

        if run.strike {
            result.push_str(" strike=\"sngStrike\"");
        }

        if run.size > 0.0 {
            result.push_str(&format!(" sz=\"{}\"", (run.size * 100.0).round() as i64));
        }

        let detailed = !run.color.is_empty() || !run.font.is_empty();

        if !detailed {
            result.push_str("/>");
        } else {
            result.push('>');

            if !run.color.is_empty() {
                result.push_str("<a:solidFill><a:srgbClr val=\"");
                xml::escape_into(&run.color, result);
                result.push_str("\"/></a:solidFill>");
            }

            if !run.font.is_empty() {
                result.push_str("<a:latin typeface=\"");
                xml::escape_into(&run.font, result);
                result.push_str("\"/><a:ea typeface=\"");
                xml::escape_into(&run.font, result);
                result.push_str("\"/>");
            }

            result.push_str("</a:rPr>");
        }

        result.push_str("<a:t>");
        xml::escape_into(piece, result);
        result.push_str("</a:t></a:r>");
    }
}