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

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

#[derive(Debug, Clone)]
pub struct ParaCharShape {
    pub char_positions: Vec<CharPositionShape>,
}

#[derive(Debug, Clone)]
pub struct CharPositionShape {
    pub position: u32,
    pub char_shape_id: u16,
}

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

        // Read position-shape pairs
        while reader.remaining() >= 8 {
            let position = reader.read_u32()?;
            let char_shape_id = reader.read_u32()? as u16; // Only lower 16 bits used

            char_positions.push(CharPositionShape {
                position,
                char_shape_id,
            });
        }

        Ok(Self { char_positions })
    }

    /// Get the character shape ID at a specific character position
    pub fn get_shape_at_position(&self, char_pos: u32) -> Option<u16> {
        // Find the shape that applies to this position
        let mut current_shape = None;

        for pos_shape in &self.char_positions {
            if pos_shape.position <= char_pos {
                current_shape = Some(pos_shape.char_shape_id);
            } else {
                break;
            }
        }

        current_shape
    }

    /// Create a new ParaCharShape with a single character shape for entire text
    pub fn new_single_shape(char_shape_id: u16) -> Self {
        Self {
            char_positions: vec![CharPositionShape {
                position: 0,
                char_shape_id,
            }],
        }
    }

    /// Create a new ParaCharShape with multiple character shapes for text ranges
    pub fn new_with_ranges(ranges: Vec<(u32, u16)>) -> Self {
        let mut char_positions = Vec::new();

        for (position, char_shape_id) in ranges {
            char_positions.push(CharPositionShape {
                position,
                char_shape_id,
            });
        }

        // Sort by position to ensure correct ordering
        char_positions.sort_by_key(|p| p.position);

        Self { char_positions }
    }

    /// Add a character shape change at a specific position
    pub fn add_shape_at_position(&mut self, position: u32, char_shape_id: u16) {
        // Remove any existing shape at this exact position
        self.char_positions.retain(|p| p.position != position);

        // Add new shape
        self.char_positions.push(CharPositionShape {
            position,
            char_shape_id,
        });

        // Re-sort by position
        self.char_positions.sort_by_key(|p| p.position);
    }

    /// Apply a character shape to a range of characters
    pub fn apply_shape_to_range(&mut self, start_pos: u32, end_pos: u32, char_shape_id: u16) {
        // Remove any shapes that are completely within this range
        self.char_positions
            .retain(|p| !(p.position > start_pos && p.position < end_pos));

        // Add shape at start position
        self.add_shape_at_position(start_pos, char_shape_id);

        // If there was a different shape before start_pos, restore it at end_pos
        if let Some(prev_shape) = self.get_shape_before_position(start_pos) {
            if prev_shape != char_shape_id {
                self.add_shape_at_position(end_pos, prev_shape);
            }
        }
    }

    /// Get the character shape ID that was active before a specific position
    fn get_shape_before_position(&self, position: u32) -> Option<u16> {
        let mut prev_shape = None;

        for pos_shape in &self.char_positions {
            if pos_shape.position < position {
                prev_shape = Some(pos_shape.char_shape_id);
            } else {
                break;
            }
        }

        prev_shape
    }

    /// Convert to bytes for serialization
    pub fn to_bytes(&self) -> Vec<u8> {
        use byteorder::{LittleEndian, WriteBytesExt};
        use std::io::Cursor;

        let mut data = Vec::new();
        let mut writer = Cursor::new(&mut data);

        // Write number of position shapes
        writer
            .write_u32::<LittleEndian>(self.char_positions.len() as u32)
            .unwrap();

        // Write each position-shape pair
        for char_pos in &self.char_positions {
            writer.write_u32::<LittleEndian>(char_pos.position).unwrap();
            writer
                .write_u32::<LittleEndian>(char_pos.char_shape_id as u32)
                .unwrap();
        }

        data
    }
}