slide.rs

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

use crate::error::Error;
use crate::paragraph::{Align, Run};
use crate::xml::{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 {
    /// 中の続きをつないだ文字
    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 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 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,
    }
}