pdf_parser 0.1.0

PDF parser
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use crate::{error::PdfResult, objects::Dictionary, Resolve};

use super::state::StateModel;

/// A text annotation represents a "sticky note" attached to a point in the PDF document.
///
/// When closed, the annotation shall appear as an icon; when open, it shall display a pop-up
/// window containing the text of the note in a font and size chosen by the conforming reader.
/// Text annotations shall not scale and rotate with the page; they shall behave as if the
/// NoZoom and NoRotate annotation flags were always set
#[derive(Debug)]
pub(crate) struct TextAnnotation {
    /// A flag specifying whether the annotation shall initially be displayed open.
    ///
    /// Default value: false (closed).
    is_open: bool,

    /// The name of an icon that shall be used in displaying the annotation.
    ///
    /// Conforming readers shall provide predefined icon appearances for at least the
    /// following standard names:
    ///   * Comment
    ///   * Key
    ///   * Note
    ///   * Help
    ///   * NewParagraph
    ///   * Paragraph
    ///   * Insert
    ///
    /// Additional names may be supported as well.
    ///
    /// Default value: Note.
    name: TextAnnotationName,

    /// The state to which the original annotation shall be set
    state: Option<StateModel>,
}

#[derive(Debug)]
enum TextAnnotationName {
    Comment,
    Key,
    Note,
    Help,
    NewParagraph,
    Paragraph,
    Insert,
    Other(String),
}

impl TextAnnotationName {
    pub fn from_str(s: String) -> Self {
        match s.as_ref() {
            "Comment" => Self::Comment,
            "Key" => Self::Key,
            "Note" => Self::Note,
            "Help" => Self::Help,
            "NewParagraph" => Self::NewParagraph,
            "Paragraph" => Self::Paragraph,
            "Insert" => Self::Insert,
            _ => Self::Other(s),
        }
    }
}

impl Default for TextAnnotationName {
    fn default() -> Self {
        Self::Note
    }
}

impl TextAnnotation {
    const TYPE: &'static str = "Text";

    pub fn from_dict(dict: &mut Dictionary, resolver: &mut dyn Resolve) -> PdfResult<Self> {
        let is_open = dict.get_bool("Open", resolver)?.unwrap_or(false);
        let name = dict
            .get_name("Name", resolver)?
            .map(TextAnnotationName::from_str)
            .unwrap_or_default();

        let state = if let Some(state) = dict.get_string("State", resolver)? {
            let state_model = dict.expect_string("StateModel", resolver)?;
            Some(StateModel::with_state(&state_model, &state)?)
        } else if let Some(state_model) = dict.get_string("StateModel", resolver)? {
            Some(StateModel::default(&state_model)?)
        } else {
            None
        };

        Ok(Self {
            is_open,
            name,
            state,
        })
    }
}