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

use crate::error::Result;
use crate::parser::record::Record;

#[derive(Debug, Clone)]
pub struct TabDef {
    pub properties: u32,
    pub tabs: Vec<Tab>,
}

#[derive(Debug, Clone)]
pub struct Tab {
    pub position: u32,
    pub tab_type: u8,
    pub leader_type: u8,
}

impl TabDef {
    pub fn from_record(record: &Record) -> Result<Self> {
        let mut reader = record.data_reader();

        if reader.remaining() < 4 {
            return Err(crate::error::HwpError::ParseError(format!(
                "TabDef record too small: {} bytes",
                reader.remaining()
            )));
        }

        let properties = reader.read_u32()?;
        let mut tabs = Vec::new();

        // Each tab entry is 6 bytes (4 bytes position + 1 byte type + 1 byte leader)
        while reader.remaining() >= 6 {
            let tab = Tab {
                position: reader.read_u32()?,
                tab_type: reader.read_u8()?,
                leader_type: reader.read_u8()?,
            };
            tabs.push(tab);
        }

        Ok(Self { properties, tabs })
    }
}
impl TabDef {
    /// Create a new default TabDef for writing
    /// Matches HWP template (empty tabs, properties = 0)
    pub fn new_default() -> Self {
        Self {
            properties: 0,
            tabs: Vec::new(), // No tabs (template default)
        }
    }
}

impl Tab {
    pub fn is_left_aligned(&self) -> bool {
        self.tab_type & 0x03 == 0
    }

    pub fn is_center_aligned(&self) -> bool {
        self.tab_type & 0x03 == 1
    }

    pub fn is_right_aligned(&self) -> bool {
        self.tab_type & 0x03 == 2
    }

    pub fn is_decimal_aligned(&self) -> bool {
        self.tab_type & 0x03 == 3
    }

    pub fn has_leader(&self) -> bool {
        self.leader_type != 0
    }
}