presentation.rs

//! pptx を開く、作る、直す
//!
//! # 開く
//!
//! ```no_run
//! use folio::presentation::Presentation;
//! use std::path::Path;
//!
//! let mut file = Presentation::open(Path::new("deck.pptx")).unwrap();
//!
//! for index in 0..file.count() {
//!     println!("{}", file.read(index).unwrap().text());
//! }
//! ```
//!
//! # 作る
//!
//! 枚数は先に渡す。`[Content_Types].xml` をファイルの先頭に置くために、
//! 何枚入るかを書き始める前に決めておく必要があるためである。
//! 位置と大きさは [`INCH`] 単位で指定する。
//!
//! ```no_run
//! use folio::presentation::Writer;
//! use folio::slide::{INCH, Shape, Slide};
//! use std::path::Path;
//!
//! let mut writer = Writer::create(Path::new("out.pptx"), 1).unwrap();
//! let title = Shape::text("題", INCH, INCH, INCH * 11, INCH, &["folio"]);
//! writer.slide(0, &Slide::new(vec![title])).unwrap();
//! writer.finish().unwrap();
//! ```
//!
//! # 直す
//!
//! [`Writer::edit`] は、書き直す枚だけを入れ替える。図形の外にある背景、切り替え、
//! 差し込み口の書式は、そのまま残る。書き直さない枚とほかのパートは、圧縮したまま写す。

use crate::error::Error;
use crate::package::{self, Package};
use crate::slide::{self, Slide};
use crate::xml::{Event, Reader};
use std::path::Path;


/// 図形の名前空間
const DRAWING: &str = "http://schemas.openxmlformats.org/drawingml/2006/main";

/// スライドの名前空間
const MAIN: &str = "http://schemas.openxmlformats.org/presentationml/2006/main";

/// 関係の名前空間
const RELATION: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";

/// XML の宣言
const HEAD: &str = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";

/// スライドの幅。16 対 9 の 13.333 インチ
const WIDTH: i64 = 12192000;

/// スライドの高さ。7.5 インチ
const HEIGHT: i64 = 6858000;

/// 図形をまとめる入れ物。どのスライドにも要る
const GROUP: &str = "<p:nvGrpSpPr><p:cNvPr id=\"1\" name=\"\"/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr/>";


/// どちらの形式を開いたか
enum Origin {
    /// pptx
    Package(Package),
    /// ppt。読み込んだスライドを持つ
    Record(Vec<Slide>),
}


/// 読むために開いたプレゼンテーション
pub struct Presentation {
    source: Origin,
    main: String,
    part: Vec<String>,
}


impl Presentation {
    /// pptx か ppt を開く
    ///
    /// 先頭のバイトを見て、どちらの形式かを決める。読む側は形式を気にしなくてよい。
    pub fn open(path: &Path) -> Result<Presentation, Error> {
        if crate::cfb::is_compound(path) {
            return open_record(path);
        }

        let mut package = Package::open(path)?;
        let main = package.main()?;
        let listed = read_order(&mut package, &main)?;
        let link = package.relationship(&main)?;
        let mut part = Vec::with_capacity(listed.len());

        for id in listed {
            let Some(one) = link.iter().find(|one| one.id == id) else {
                return Err(Error::at(format!("スライド {id} の指し先がありません"), &main));
            };

            part.push(one.target.clone());
        }

        Ok(Presentation {source: Origin::Package(package), main, part})
    }

    /// 何枚あるか
    pub fn count(&self) -> usize {
        match &self.source {
            Origin::Package(_) => self.part.len(),
            Origin::Record(slide) => slide.len(),
        }
    }

    /// 旧形式かどうか
    pub fn is_record(&self) -> bool {
        matches!(self.source, Origin::Record(_))
    }

    /// スライドのパートの名前。並び順
    pub fn slide(&self) -> &[String] {
        &self.part
    }

    /// 本体のパートの名前
    pub fn main(&self) -> &str {
        &self.main
    }

    /// 包みそのもの。folio が読まないパートを自分で取り出すときに使う
    ///
    /// 旧形式には包みがないので None を返す。
    pub fn package(&mut self) -> Option<&mut Package> {
        match &mut self.source {
            Origin::Package(one) => Some(one),
            Origin::Record(_) => None,
        }
    }

    /// 1 枚読む。番号は 0 から
    pub fn read(&mut self, index: usize) -> Result<Slide, Error> {
        if let Origin::Record(all) = &self.source {
            let Some(one) = all.get(index) else {
                return Err(Error::new(format!("{index} 枚目はありません")));
            };

            return Ok(one.clone());
        }

        let Some(part) = self.part.get(index) else {
            return Err(Error::new(format!("{index} 枚目はありません")));
        };

        let part = part.clone();

        let Origin::Package(package) = &mut self.source else {
            return Err(Error::new("包みがありません"));
        };

        let mut reader = package.reader(&part)?;
        slide::read(&mut reader).map_err(|error| error.within(&part))
    }

    /// 全部の文字を、スライドごとに改行でつないで返す
    pub fn text(&mut self) -> Result<String, Error> {
        let mut result = String::new();

        for index in 0..self.count() {
            if index > 0 {
                result.push('\n');
            }

            result.push_str(&self.read(index)?.text());
            result.push('\n');
        }

        Ok(result)
    }
}


/// 作る、または直すために開いたプレゼンテーション
pub struct Writer {
    package: package::Writer,
    /// 直す元。作るだけのときは None
    source: Option<Package>,
    /// 書くスライドのパート
    part: Vec<String>,
    /// 書き終えた枚
    done: Vec<bool>,
    /// 組み立て中の中身
    buffer: String,
}


impl Writer {
    /// 新しい pptx を作る。枚数を先に渡す
    pub fn create(path: &Path, count: usize) -> Result<Writer, Error> {
        if count == 0 {
            return Err(Error::new("スライドが 1 枚もありません"));
        }

        let part: Vec<String> = (1..=count).map(|index| format!("ppt/slides/slide{index}.xml")).collect();
        let mut package = package::Writer::create(path)?;
        package.add("[Content_Types].xml", content_type(count).as_bytes())?;
        package.add("_rels/.rels", root_relationship().as_bytes())?;
        package.add("ppt/presentation.xml", presentation(count).as_bytes())?;
        package.add("ppt/_rels/presentation.xml.rels", main_relationship(count).as_bytes())?;
        package.add("ppt/slideMasters/slideMaster1.xml", master().as_bytes())?;
        package.add("ppt/slideMasters/_rels/slideMaster1.xml.rels", master_relationship().as_bytes())?;
        package.add("ppt/slideLayouts/slideLayout1.xml", layout().as_bytes())?;
        package.add("ppt/slideLayouts/_rels/slideLayout1.xml.rels", layout_relationship().as_bytes())?;
        package.add("ppt/theme/theme1.xml", theme().as_bytes())?;

        for index in 1..=count {
            package.add(
                &format!("ppt/slides/_rels/slide{index}.xml.rels"),
                slide_relationship().as_bytes(),
            )?;
        }

        Ok(Writer {
            package,
            source: None,
            done: vec![false; count],
            part,
            buffer: String::with_capacity(16 * 1024),
        })
    }

    /// すでにある pptx を直す。書き直す枚の番号を渡す
    pub fn edit(file: Presentation, path: &Path, index: &[usize]) -> Result<Writer, Error> {
        let source_part = file.part.clone();

        let Origin::Package(mut source) = file.source else {
            return Err(Error::new("旧形式のファイルは直せません。pptx として作り直してください"));
        };

        let mut part = Vec::with_capacity(index.len());

        for one in index {
            let Some(name) = source_part.get(*one) else {
                return Err(Error::new(format!("{one} 枚目はありません")));
            };

            part.push(name.clone());
        }

        let skip: Vec<&str> = part.iter().map(|one| one.as_str()).collect();
        let mut package = package::Writer::create(path)?;
        package.carry(&mut source, &skip)?;

        Ok(Writer {
            package,
            source: Some(source),
            done: vec![false; part.len()],
            part,
            buffer: String::with_capacity(16 * 1024),
        })
    }

    /// 1 枚書く
    ///
    /// 番号は、作るときは何枚目か、直すときは [`Writer::edit`] に渡した並びの何番目かである。
    pub fn slide(&mut self, index: usize, one: &Slide) -> Result<(), Error> {
        let Some(part) = self.part.get(index) else {
            return Err(Error::new(format!("{index} 枚目は書くと決めていません")));
        };

        if self.done[index] {
            return Err(Error::new(format!("{index} 枚目はもう書きました")));
        }

        let part = part.clone();
        let (head, tail) = self.frame(&part)?;
        self.buffer.clear();
        slide::shape_into(&mut self.buffer, &one.shape);

        self.package.start(&part)?;
        self.package.write(&head)?;
        self.package.write(self.buffer.as_bytes())?;
        self.package.write(&tail)?;
        self.package.close()?;
        self.done[index] = true;
        Ok(())
    }

    /// 書き終える
    pub fn finish(mut self) -> Result<(), Error> {
        if let Some(source) = self.source.as_mut() {
            return self.package.carry(source, &[]).and_then(|_| self.package.finish());
        }

        for index in 0..self.part.len() {
            if self.done[index] {
                continue;
            }

            let part = self.part[index].clone();
            let (head, tail) = self.frame(&part)?;
            let mut whole = head;
            whole.extend_from_slice(&tail);
            self.package.add(&part, &whole)?;
        }

        self.package.finish()
    }

    /// スライドの図形の前と後ろを用意する
    fn frame(&mut self, part: &str) -> Result<(Vec<u8>, Vec<u8>), Error> {
        let Some(source) = self.source.as_mut() else {
            let head = format!(
                "{HEAD}<p:sld xmlns:a=\"{DRAWING}\" xmlns:r=\"{RELATION}\" xmlns:p=\"{MAIN}\">\
                 <p:cSld><p:spTree>{GROUP}"
            );

            let tail = "</p:spTree></p:cSld><p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr></p:sld>";
            return Ok((head.into_bytes(), tail.as_bytes().to_vec()));
        };

        let mut reader = source.archive.reader(part)?;
        let mut cut = package::split(&mut reader, b"<p:spTree", b"</p:spTree>", 0)
            .map_err(|error| error.within(part))?;

        if !cut.found {
            let head = format!(
                "{HEAD}<p:sld xmlns:a=\"{DRAWING}\" xmlns:r=\"{RELATION}\" xmlns:p=\"{MAIN}\">\
                 <p:cSld><p:spTree>{GROUP}"
            );

            let tail = "</p:spTree></p:cSld><p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr></p:sld>";
            return Ok((head.into_bytes(), tail.as_bytes().to_vec()));
        }

        cut.head.extend_from_slice(b"<p:spTree>");
        cut.head.extend_from_slice(GROUP.as_bytes());

        if cut.tail.is_empty() {
            cut.tail = b"</p:spTree></p:cSld></p:sld>".to_vec();
        } else {
            let mut tail = b"</p:spTree>".to_vec();
            tail.extend_from_slice(&cut.tail);
            cut.tail = tail;
        }

        Ok((cut.head, cut.tail))
    }
}


/// ppt を開く
fn open_record(path: &Path) -> Result<Presentation, Error> {
    let mut file = crate::cfb::Compound::open(path)?;

    if !file.has("PowerPoint Document") {
        return Err(Error::new("ppt の PowerPoint Document ストリームがありません"));
    }

    let main = file.read("PowerPoint Document")?;

    let user = if file.has("Current User") {
        file.read("Current User")?
    } else {
        Vec::new()
    };

    let slide = crate::ppt::read(&main, &user)?;

    Ok(Presentation {
        source: Origin::Record(slide),
        main: "PowerPoint Document".to_string(),
        part: Vec::new(),
    })
}


/// presentation.xml から、スライドの並びを読む
fn read_order(package: &mut Package, main: &str) -> Result<Vec<String>, Error> {
    let data = package.read(main)?;
    let mut reader = Reader::over(data);
    let mut result = Vec::new();
    let mut inside = false;

    while let Some(event) = reader.next().map_err(|error| error.within(main))? {
        if event == Event::Close {
            if reader.name() == "sldIdLst" {
                inside = false;
            }

            continue;
        }

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

        match reader.name() {
            "sldIdLst" => inside = event == Event::Open,
            "sldId" if inside => result.push(reader.attribute("r:id").unwrap_or("").to_string()),
            _ => {}
        }
    }

    Ok(result)
}


/// [Content_Types].xml
fn content_type(count: usize) -> String {
    let base = "application/vnd.openxmlformats-officedocument.presentationml";
    let mut result = String::from(HEAD);
    result.push_str("<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">");
    result.push_str("<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>");
    result.push_str("<Default Extension=\"xml\" ContentType=\"application/xml\"/>");
    result.push_str(&format!("<Override PartName=\"/ppt/presentation.xml\" ContentType=\"{base}.presentation.main+xml\"/>"));
    result.push_str(&format!("<Override PartName=\"/ppt/slideMasters/slideMaster1.xml\" ContentType=\"{base}.slideMaster+xml\"/>"));
    result.push_str(&format!("<Override PartName=\"/ppt/slideLayouts/slideLayout1.xml\" ContentType=\"{base}.slideLayout+xml\"/>"));

    for index in 1..=count {
        result.push_str(&format!(
            "<Override PartName=\"/ppt/slides/slide{index}.xml\" ContentType=\"{base}.slide+xml\"/>"
        ));
    }

    result.push_str("<Override PartName=\"/ppt/theme/theme1.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.theme+xml\"/>");
    result.push_str("</Types>");
    result
}


/// _rels/.rels
fn root_relationship() -> String {
    format!(
        "{HEAD}<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\
         <Relationship Id=\"rId1\" Type=\"{RELATION}/officeDocument\" Target=\"ppt/presentation.xml\"/>\
         </Relationships>"
    )
}


/// ppt/presentation.xml
fn presentation(count: usize) -> String {
    let mut result = String::from(HEAD);
    result.push_str(&format!(
        "<p:presentation xmlns:a=\"{DRAWING}\" xmlns:r=\"{RELATION}\" xmlns:p=\"{MAIN}\">\
         <p:sldMasterIdLst><p:sldMasterId id=\"2147483648\" r:id=\"rId1\"/></p:sldMasterIdLst><p:sldIdLst>"
    ));

    for index in 1..=count {
        result.push_str(&format!(
            "<p:sldId id=\"{}\" r:id=\"rId{}\"/>",
            255 + index,
            index + 1
        ));
    }

    result.push_str("</p:sldIdLst>");
    result.push_str(&format!("<p:sldSz cx=\"{WIDTH}\" cy=\"{HEIGHT}\"/>"));
    result.push_str("<p:notesSz cx=\"6858000\" cy=\"9144000\"/></p:presentation>");
    result
}


/// ppt/_rels/presentation.xml.rels
fn main_relationship(count: usize) -> String {
    let mut result = String::from(HEAD);
    result.push_str("<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
    result.push_str(&format!(
        "<Relationship Id=\"rId1\" Type=\"{RELATION}/slideMaster\" Target=\"slideMasters/slideMaster1.xml\"/>"
    ));

    for index in 1..=count {
        result.push_str(&format!(
            "<Relationship Id=\"rId{}\" Type=\"{RELATION}/slide\" Target=\"slides/slide{index}.xml\"/>",
            index + 1
        ));
    }

    result.push_str(&format!(
        "<Relationship Id=\"rId{}\" Type=\"{RELATION}/theme\" Target=\"theme/theme1.xml\"/>",
        count + 2
    ));

    result.push_str("</Relationships>");
    result
}


/// ppt/slideMasters/slideMaster1.xml
fn master() -> String {
    let map = "bg1=\"lt1\" tx1=\"dk1\" bg2=\"lt2\" tx2=\"dk2\" accent1=\"accent1\" accent2=\"accent2\" \
               accent3=\"accent3\" accent4=\"accent4\" accent5=\"accent5\" accent6=\"accent6\" \
               hlink=\"hlink\" folHlink=\"folHlink\"";

    format!(
        "{HEAD}<p:sldMaster xmlns:a=\"{DRAWING}\" xmlns:r=\"{RELATION}\" xmlns:p=\"{MAIN}\">\
         <p:cSld><p:bg><p:bgPr><a:solidFill><a:schemeClr val=\"bg1\"/></a:solidFill><a:effectLst/></p:bgPr></p:bg>\
         <p:spTree>{GROUP}</p:spTree></p:cSld><p:clrMap {map}/>\
         <p:sldLayoutIdLst><p:sldLayoutId id=\"2147483649\" r:id=\"rId1\"/></p:sldLayoutIdLst>\
         </p:sldMaster>"
    )
}


/// ppt/slideMasters/_rels/slideMaster1.xml.rels
fn master_relationship() -> String {
    format!(
        "{HEAD}<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\
         <Relationship Id=\"rId1\" Type=\"{RELATION}/slideLayout\" Target=\"../slideLayouts/slideLayout1.xml\"/>\
         <Relationship Id=\"rId2\" Type=\"{RELATION}/theme\" Target=\"../theme/theme1.xml\"/>\
         </Relationships>"
    )
}


/// ppt/slideLayouts/slideLayout1.xml
fn layout() -> String {
    format!(
        "{HEAD}<p:sldLayout xmlns:a=\"{DRAWING}\" xmlns:r=\"{RELATION}\" xmlns:p=\"{MAIN}\" \
         type=\"blank\" preserve=\"1\"><p:cSld name=\"白紙\"><p:spTree>{GROUP}</p:spTree></p:cSld>\
         <p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr></p:sldLayout>"
    )
}


/// ppt/slideLayouts/_rels/slideLayout1.xml.rels
fn layout_relationship() -> String {
    format!(
        "{HEAD}<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\
         <Relationship Id=\"rId1\" Type=\"{RELATION}/slideMaster\" Target=\"../slideMasters/slideMaster1.xml\"/>\
         </Relationships>"
    )
}


/// ppt/slides/_rels/slideN.xml.rels
fn slide_relationship() -> String {
    format!(
        "{HEAD}<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\
         <Relationship Id=\"rId1\" Type=\"{RELATION}/slideLayout\" Target=\"../slideLayouts/slideLayout1.xml\"/>\
         </Relationships>"
    )
}


/// ppt/theme/theme1.xml
///
/// 色と書体の対応は、スライドマスタが必ず 1 つ持っていなければならない。
/// 見た目を決めるためではなく、形をそろえるために最小の組を置く。
fn theme() -> String {
    let mut result = String::from(HEAD);
    result.push_str(&format!("<a:theme xmlns:a=\"{DRAWING}\" name=\"folio\"><a:themeElements>"));
    result.push_str("<a:clrScheme name=\"folio\">");
    result.push_str("<a:dk1><a:sysClr val=\"windowText\" lastClr=\"000000\"/></a:dk1>");
    result.push_str("<a:lt1><a:sysClr val=\"window\" lastClr=\"FFFFFF\"/></a:lt1>");
    result.push_str("<a:dk2><a:srgbClr val=\"44546A\"/></a:dk2>");
    result.push_str("<a:lt2><a:srgbClr val=\"E7E6E6\"/></a:lt2>");

    for (name, color) in [
        ("accent1", "4472C4"),
        ("accent2", "ED7D31"),
        ("accent3", "A5A5A5"),
        ("accent4", "FFC000"),
        ("accent5", "5B9BD5"),
        ("accent6", "70AD47"),
        ("hlink", "0563C1"),
        ("folHlink", "954F72"),
    ] {
        result.push_str(&format!("<a:{name}><a:srgbClr val=\"{color}\"/></a:{name}>"));
    }

    result.push_str("</a:clrScheme><a:fontScheme name=\"folio\">");

    for name in ["majorFont", "minorFont"] {
        result.push_str(&format!(
            "<a:{name}><a:latin typeface=\"Calibri\"/><a:ea typeface=\"\"/><a:cs typeface=\"\"/></a:{name}>"
        ));
    }

    result.push_str("</a:fontScheme><a:fmtScheme name=\"folio\"><a:fillStyleLst>");

    for _ in 0..3 {
        result.push_str("<a:solidFill><a:schemeClr val=\"phClr\"/></a:solidFill>");
    }

    result.push_str("</a:fillStyleLst><a:lnStyleLst>");

    for _ in 0..3 {
        result.push_str(
            "<a:ln w=\"6350\" cap=\"flat\" cmpd=\"sng\" algn=\"ctr\">\
             <a:solidFill><a:schemeClr val=\"phClr\"/></a:solidFill><a:prstDash val=\"solid\"/></a:ln>",
        );
    }

    result.push_str("</a:lnStyleLst><a:effectStyleLst>");

    for _ in 0..3 {
        result.push_str("<a:effectStyle><a:effectLst/></a:effectStyle>");
    }

    result.push_str("</a:effectStyleLst><a:bgFillStyleLst>");

    for _ in 0..3 {
        result.push_str("<a:solidFill><a:schemeClr val=\"phClr\"/></a:solidFill>");
    }

    result.push_str("</a:bgFillStyleLst></a:fmtScheme></a:themeElements></a:theme>");
    result
}