hwpers 0.5.0

A Rust library for parsing Korean Hangul Word Processor (HWP) files with full layout rendering support
Documentation 
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use crate::error::{HwpError, Result};
use crate::reader::StreamReader;

const HWP_SIGNATURE: &[u8] = b"HWP Document File";

#[derive(Debug, Clone)]
pub struct FileHeader {
    pub signature: [u8; 32],
    pub version: u32,
    pub flags: u32,
    pub reserved: [u8; 216],
}

impl FileHeader {
    pub fn parse(data: Vec<u8>) -> Result<Self> {
        if data.len() < 256 {
            return Err(HwpError::InvalidFormat(
                "FileHeader must be 256 bytes".to_string(),
            ));
        }

        let mut reader = StreamReader::new(data);

        let mut signature = [0u8; 32];
        signature.copy_from_slice(&reader.read_bytes(32)?);

        // Verify signature
        if &signature[..17] != HWP_SIGNATURE {
            return Err(HwpError::InvalidFormat("Invalid HWP signature".to_string()));
        }

        let version = reader.read_u32()?;
        let flags = reader.read_u32()?;

        let mut reserved = [0u8; 216];
        reserved.copy_from_slice(&reader.read_bytes(216)?);

        Ok(Self {
            signature,
            version,
            flags,
            reserved,
        })
    }

    pub fn is_compressed(&self) -> bool {
        (self.flags & 0x01) != 0
    }

    pub fn is_encrypted(&self) -> bool {
        (self.flags & 0x02) != 0
    }

    pub fn is_distribute(&self) -> bool {
        (self.flags & 0x04) != 0
    }

    pub fn is_script(&self) -> bool {
        (self.flags & 0x08) != 0
    }

    pub fn is_drm(&self) -> bool {
        (self.flags & 0x10) != 0
    }

    pub fn is_xml_template(&self) -> bool {
        (self.flags & 0x20) != 0
    }

    pub fn is_history(&self) -> bool {
        (self.flags & 0x40) != 0
    }

    pub fn is_sign(&self) -> bool {
        (self.flags & 0x80) != 0
    }

    pub fn is_certificate_encrypt(&self) -> bool {
        (self.flags & 0x100) != 0
    }

    pub fn is_sign_spare(&self) -> bool {
        (self.flags & 0x200) != 0
    }

    pub fn is_certificate_drm(&self) -> bool {
        (self.flags & 0x400) != 0
    }

    pub fn is_ccl(&self) -> bool {
        (self.flags & 0x800) != 0
    }

    pub fn version_string(&self) -> String {
        let major = (self.version >> 24) & 0xFF;
        let minor = (self.version >> 16) & 0xFF;
        let build = (self.version >> 8) & 0xFF;
        let revision = self.version & 0xFF;

        format!("{major}.{minor}.{build}.{revision}")
    }
}
impl FileHeader {
    /// Create a new default FileHeader for writing
    /// Uses version 5.0.3.4 and NO compression for maximum compatibility
    /// (matching hwplib's BlankFileMaker.java)
    pub fn new_default() -> Self {
        let mut signature = [0u8; 32];
        signature[..17].copy_from_slice(HWP_SIGNATURE);

        let mut reserved = [0u8; 216];
        // Reserved offset 4 (FileHeader offset 0x2C) = 0x04
        // This is required for HWP compatibility
        reserved[4] = 0x04;

        Self {
            signature,
            version: 0x05000304, // HWP 5.0.3.4 (compatible version)
            flags: 0x00,         // NO compression for compatibility
            reserved,
        }
    }

    /// Convert FileHeader to bytes for writing
    pub fn to_bytes(&self) -> Vec<u8> {
        let mut bytes = Vec::with_capacity(256);
        bytes.extend_from_slice(&self.signature);
        bytes.extend_from_slice(&self.version.to_le_bytes());
        bytes.extend_from_slice(&self.flags.to_le_bytes());
        bytes.extend_from_slice(&self.reserved);
        bytes
    }

    /// Set compression flag
    pub fn set_compressed(&mut self, compressed: bool) -> &mut Self {
        if compressed {
            self.flags |= 0x01;
        } else {
            self.flags &= !0x01;
        }
        self
    }

    /// Set encryption flag
    pub fn set_encrypted(&mut self, encrypted: bool) -> &mut Self {
        if encrypted {
            self.flags |= 0x02;
        } else {
            self.flags &= !0x02;
        }
        self
    }

    /// Set document version
    pub fn set_version(&mut self, major: u8, minor: u8, build: u8, revision: u8) -> &mut Self {
        self.version = ((major as u32) << 24)
            | ((minor as u32) << 16)
            | ((build as u32) << 8)
            | (revision as u32);
        self
    }
}